actionpack_csi 2.3.5.p6

data/lib/action_view/renderable.rb

@@ -0,0 +1,95 @@
+# encoding: utf-8
+
+module ActionView
+  # NOTE: The template that this mixin is being included into is frozen
+  # so you cannot set or modify any instance variables
+  module Renderable #:nodoc:
+    extend ActiveSupport::Memoizable
+
+    def filename
+      'compiled-template'
+    end
+
+    def handler
+      Template.handler_class_for_extension(extension)
+    end
+    memoize :handler
+
+    def compiled_source
+      handler.call(self)
+    end
+
+    def method_name_without_locals
+      ['_run', extension, method_segment].compact.join('_')
+    end
+    memoize :method_name_without_locals
+
+    def render(view, local_assigns = {})
+      compile(local_assigns)
+
+      view.with_template self do
+        view.send(:_evaluate_assigns_and_ivars)
+        view.send(:_set_controller_content_type, mime_type) if respond_to?(:mime_type)
+
+        view.send(method_name(local_assigns), local_assigns) do |*names|
+          ivar = :@_proc_for_layout
+          if !view.instance_variable_defined?(:"@content_for_#{names.first}") && view.instance_variable_defined?(ivar) && (proc = view.instance_variable_get(ivar))
+            view.capture(*names, &proc)
+          elsif view.instance_variable_defined?(ivar = :"@content_for_#{names.first || :layout}")
+            view.instance_variable_get(ivar)
+          end
+        end
+      end
+    end
+
+    def method_name(local_assigns)
+      if local_assigns && local_assigns.any?
+        method_name = method_name_without_locals.dup
+        method_name << "_locals_#{local_assigns.keys.map { |k| k.to_s }.sort.join('_')}"
+      else
+        method_name = method_name_without_locals
+      end
+      method_name.to_sym
+    end
+
+    private
+      # Compile and evaluate the template's code (if necessary)
+      def compile(local_assigns)
+        render_symbol = method_name(local_assigns)
+
+        if !Base::CompiledTemplates.method_defined?(render_symbol) || recompile?
+          compile!(render_symbol, local_assigns)
+        end
+      end
+
+      def compile!(render_symbol, local_assigns)
+        locals_code = local_assigns.keys.map { |key| "#{key} = local_assigns[:#{key}];" }.join
+
+        source = <<-end_src
+          def #{render_symbol}(local_assigns)
+            old_output_buffer = output_buffer;#{locals_code};#{compiled_source}
+          ensure
+            self.output_buffer = old_output_buffer
+          end
+        end_src
+
+        begin
+          ActionView::Base::CompiledTemplates.module_eval(source, filename, 0)
+        rescue Errno::ENOENT => e
+          raise e # Missing template file, re-raise for Base to rescue
+        rescue Exception => e # errors from template code
+          if logger = defined?(ActionController) && Base.logger
+            logger.debug "ERROR: compiling #{render_symbol} RAISED #{e}"
+            logger.debug "Function body: #{source}"
+            logger.debug "Backtrace: #{e.backtrace.join("\n")}"
+          end
+
+          raise ActionView::TemplateError.new(self, {}, e)
+        end
+      end
+
+      def recompile?
+        false
+      end
+  end
+end

data/lib/action_view/renderable_partial.rb

@@ -0,0 +1,47 @@
+module ActionView
+  # NOTE: The template that this mixin is being included into is frozen
+  # so you cannot set or modify any instance variables
+  module RenderablePartial #:nodoc:
+    extend ActiveSupport::Memoizable
+
+    def variable_name
+      name.sub(/\A_/, '').to_sym
+    end
+    memoize :variable_name
+
+    def counter_name
+      "#{variable_name}_counter".to_sym
+    end
+    memoize :counter_name
+
+    def render(view, local_assigns = {})
+      if defined? ActionController
+        ActionController::Base.benchmark("Rendered #{path_without_format_and_extension}", Logger::DEBUG, false) do
+          super
+        end
+      else
+        super
+      end
+    end
+
+    def render_partial(view, object = nil, local_assigns = {}, as = nil)
+      object ||= local_assigns[:object] || local_assigns[variable_name]
+
+      if object.nil? && view.respond_to?(:controller)
+        ivar = :"@#{variable_name}"
+        object =
+          if view.controller.instance_variable_defined?(ivar)
+            ActiveSupport::Deprecation::DeprecatedObjectProxy.new(
+              view.controller.instance_variable_get(ivar),
+              "#{ivar} will no longer be implicitly assigned to #{variable_name}")
+          end
+      end
+
+      # Ensure correct object is reassigned to other accessors
+      local_assigns[:object] = local_assigns[variable_name] = object
+      local_assigns[as] = object if as
+
+      render_template(view, local_assigns)
+    end
+  end
+end

data/lib/action_view/safe_buffer.rb

@@ -0,0 +1,28 @@
+
+module ActionView #:nodoc:
+  class SafeBuffer < String
+    def <<(value)
+      if value.html_safe?
+        super(value)
+      else
+        super(ERB::Util.h(value))
+      end
+    end
+
+    def concat(value)
+      self << value
+    end
+
+    def html_safe?
+      true
+    end
+
+    def html_safe!
+      self
+    end
+
+    def to_s
+      self
+    end
+  end
+end

data/lib/action_view/template.rb

@@ -0,0 +1,252 @@
+module ActionView #:nodoc:
+  class Template
+    class Path
+      attr_reader :path, :paths
+      delegate :hash, :inspect, :to => :path
+
+      def initialize(path)
+        raise ArgumentError, "path already is a Path class" if path.is_a?(Path)
+        @path = (path.ends_with?(File::SEPARATOR) ? path.to(-2) : path).freeze
+      end
+
+      def to_s
+        if defined?(RAILS_ROOT)
+          path.to_s.sub(/^#{Regexp.escape(File.expand_path(RAILS_ROOT))}\//, '')
+        else
+          path.to_s
+        end
+      end
+
+      def to_str
+        path.to_str
+      end
+
+      def ==(path)
+        to_str == path.to_str
+      end
+
+      def eql?(path)
+        to_str == path.to_str
+      end
+
+      # Returns a ActionView::Template object for the given path string. The
+      # input path should be relative to the view path directory,
+      # +hello/index.html.erb+. This method also has a special exception to
+      # match partial file names without a handler extension. So
+      # +hello/index.html+ will match the first template it finds with a
+      # known template extension, +hello/index.html.erb+. Template extensions
+      # should not be confused with format extensions +html+, +js+, +xml+,
+      # etc. A format must be supplied to match a formated file. +hello/index+
+      # will never match +hello/index.html.erb+.
+      def [](path)
+      end
+
+      def load!
+      end
+
+      def self.new_and_loaded(path)
+        returning new(path) do |path|
+          path.load!
+        end
+      end
+
+      private
+        def relative_path_for_template_file(full_file_path)
+          full_file_path.split("#{@path}/").last
+        end
+    end
+
+    class EagerPath < Path
+      def initialize(path)
+        super
+        @loaded = false
+      end
+
+      def load!
+        return if @loaded
+
+        @paths = {}
+        templates_in_path do |template|
+          template.load!
+          template.accessible_paths.each do |path|
+            @paths[path] = template
+          end
+        end
+        @paths.freeze
+        @loaded = true
+      end
+
+      def [](path)
+        load! unless @loaded
+        @paths[path]
+      end
+
+      private
+        def templates_in_path
+          (Dir.glob("#{@path}/**/*/**") | Dir.glob("#{@path}/**")).each do |file|
+            yield create_template(file) unless File.directory?(file)
+          end
+        end
+
+        def create_template(file)
+          Template.new(relative_path_for_template_file(file), self)
+        end
+    end
+
+    extend TemplateHandlers
+    extend ActiveSupport::Memoizable
+    include Renderable
+
+    # Templates that are exempt from layouts
+    @@exempt_from_layout = Set.new([/\.rjs$/])
+
+    # Don't render layouts for templates with the given extensions.
+    def self.exempt_from_layout(*extensions)
+      regexps = extensions.collect do |extension|
+        extension.is_a?(Regexp) ? extension : /\.#{Regexp.escape(extension.to_s)}$/
+      end
+      @@exempt_from_layout.merge(regexps)
+    end
+
+    attr_accessor :template_path, :load_path, :base_path
+    attr_accessor :locale, :name, :format, :extension
+    attr_writer :filename
+    delegate :to_s, :to => :path
+
+    def initialize(template_path, load_path = nil)
+      @template_path, @load_path = template_path.dup, load_path
+      @base_path, @name, @locale, @format, @extension = split(template_path)
+      @base_path.to_s.gsub!(/\/$/, '') # Push to split method
+
+      # Extend with partial super powers
+      extend RenderablePartial if @name =~ /^_/
+    end
+
+    def accessible_paths
+      paths = []
+
+      if valid_extension?(extension)
+        paths << path
+        paths << path_without_extension
+        if multipart?
+          formats = format.split(".")
+          paths << "#{path_without_format_and_extension}.#{formats.first}"
+          paths << "#{path_without_format_and_extension}.#{formats.second}"
+        end
+      else
+        # template without explicit template handler should only be reachable through its exact path
+        paths << template_path
+      end
+
+      paths
+    end
+
+    def format_and_extension
+      (extensions = [format, extension].compact.join(".")).blank? ? nil : extensions
+    end
+    memoize :format_and_extension
+
+    def multipart?
+      format && format.include?('.')
+    end
+
+    def content_type
+      format.gsub('.', '/')
+    end
+
+    def mime_type
+      Mime::Type.lookup_by_extension(format) if format && defined?(::Mime)
+    end
+    memoize :mime_type
+
+    def path
+      [base_path, [name, locale, format, extension].compact.join('.')].compact.join('/')
+    end
+    memoize :path
+
+    def path_without_extension
+      [base_path, [name, locale, format].compact.join('.')].compact.join('/')
+    end
+    memoize :path_without_extension
+
+    def path_without_format_and_extension
+      [base_path, [name, locale].compact.join('.')].compact.join('/')
+    end
+    memoize :path_without_format_and_extension
+
+    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 exempt_from_layout?
+      @@exempt_from_layout.any? { |exempted| path =~ exempted }
+    end
+
+    def filename
+      # no load_path means this is an "absolute pathed" template
+      load_path ? File.join(load_path, template_path) : template_path
+    end
+    memoize :filename
+
+    def source
+      File.read(filename)
+    end
+    memoize :source
+
+    def method_segment
+      relative_path.to_s.gsub(/([^a-zA-Z0-9_])/) { $1.ord }
+    end
+    memoize :method_segment
+
+    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
+
+    def load!
+      freeze
+    end
+
+    private
+      def valid_extension?(extension)
+        !Template.registered_template_handler(extension).nil?
+      end
+
+      def valid_locale?(locale)
+        locale && I18n.available_locales.include?(locale.to_sym)
+      end
+
+      # Returns file split into an array
+      #   [base_path, name, locale, format, extension]
+      def split(file)
+        if m = file.to_s.match(/^(.*\/)?([^\.]+)\.(.*)$/)
+          [m[1], m[2], *parse_extensions(m[3])]
+        end
+      end
+
+      # returns parsed extensions as an array
+      #   [locale, format, extension]
+      def parse_extensions(extensions)
+        exts = extensions.split(".")
+
+        if extension = valid_extension?(exts.last) && exts.pop || nil
+          locale = valid_locale?(exts.first) && exts.shift || nil
+          format = exts.join('.') if exts.any? # join('.') is needed for multipart templates
+        else # no extension, just format
+          format = exts.last
+        end
+
+        [locale, format, extension]
+      end
+  end
+end

data/lib/action_view/template_error.rb

@@ -0,0 +1,99 @@
+module ActionView
+  # The TemplateError 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 TemplateError < 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.relative_path
+    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.relative_path }.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

data/lib/action_view/template_handler.rb

@@ -0,0 +1,34 @@
+# Legacy TemplateHandler stub
+module ActionView
+  module TemplateHandlers #: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 TemplateHandler
+    def self.call(template)
+      "#{name}.new(self).render(template, local_assigns)"
+    end
+
+    def initialize(view = nil)
+      @view = view
+    end
+
+    def render(template, local_assigns)
+      raise "Need to implement #{self.class.name}#render(template, local_assigns)"
+    end
+  end
+end

data/lib/action_view/template_handlers/builder.rb

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

data/lib/action_view/template_handlers/erb.rb

@@ -0,0 +1,22 @@
+module ActionView
+  module TemplateHandlers
+    class ERB < TemplateHandler
+      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 = '-'
+
+      def compile(template)
+        src = ::ERB.new("<% __in_erb_template=true %>#{template.source}", nil, erb_trim_mode, '@output_buffer').src
+
+        # 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
+end

data/lib/action_view/template_handlers/rjs.rb

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

data/lib/action_view/template_handlers.rb

@@ -0,0 +1,48 @@
+module ActionView #:nodoc:
+  module TemplateHandlers #: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, 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 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)
+      registered_template_handler(extension) || @@default_template_handlers
+    end
+  end
+end