actionpack-2.3.17-rack-upgrade 2.3.17

data/lib/action_view/reloadable_template.rb

@@ -0,0 +1,117 @@
+module ActionView #:nodoc:
+  class ReloadableTemplate < Template
+
+    class TemplateDeleted < ActionView::ActionViewError
+    end
+
+    class ReloadablePath < Template::Path
+
+      def initialize(path)
+        super
+        @paths = {}
+        new_request!
+      end
+
+      def new_request!
+        @disk_cache = {}
+      end
+      alias_method :load!, :new_request!
+
+      def [](path)
+        if found_template = @paths[path]
+          begin
+            found_template.reset_cache_if_stale!
+          rescue TemplateDeleted
+            unregister_template(found_template)
+            self[path]
+          end
+        else
+          load_all_templates_from_dir(templates_dir_from_path(path))
+          # don't ever hand out a template without running a stale check
+          (new_template = @paths[path]) && new_template.reset_cache_if_stale!
+        end
+      end
+
+      private
+        def register_template_from_file(template_full_file_path)
+          if !@paths[relative_path = relative_path_for_template_file(template_full_file_path)] && File.file?(template_full_file_path)
+            register_template(ReloadableTemplate.new(relative_path, self))
+          end
+        end
+
+        def register_template(template)
+          template.accessible_paths.each do |path|
+            @paths[path] = template
+          end
+        end
+
+        # remove (probably deleted) template from cache
+        def unregister_template(template)
+          template.accessible_paths.each do |template_path|
+            @paths.delete(template_path) if @paths[template_path] == template
+          end
+          # fill in any newly created gaps
+          @paths.values.uniq.each do |template|
+            template.accessible_paths.each {|path| @paths[path] ||= template}
+          end
+        end
+
+        # load all templates from the directory of the requested template
+        def load_all_templates_from_dir(dir)
+          # hit disk only once per template-dir/request
+          @disk_cache[dir] ||= template_files_from_dir(dir).each {|template_file| register_template_from_file(template_file)}
+        end
+
+        def templates_dir_from_path(path)
+          dirname = File.dirname(path)
+          File.join(@path, dirname == '.' ? '' : dirname)
+        end
+
+        # get all the template filenames from the dir
+        def template_files_from_dir(dir)
+          Dir.glob(File.join(dir, '*'))
+        end
+    end
+
+    module Unfreezable
+      def freeze; self; end
+    end
+
+    def initialize(*args)
+      super
+      
+      # we don't ever want to get frozen
+      extend Unfreezable
+    end
+
+    def mtime
+      File.mtime(filename)
+    end
+
+    attr_accessor :previously_last_modified
+
+    def stale?
+      previously_last_modified.nil? || previously_last_modified < mtime
+    rescue Errno::ENOENT => e
+      undef_my_compiled_methods!
+      raise TemplateDeleted
+    end
+
+    def reset_cache_if_stale!
+      if stale?
+        flush_cache 'source', 'compiled_source'
+        undef_my_compiled_methods!
+        @previously_last_modified = mtime
+      end
+      self
+    end
+
+    # remove any compiled methods that look like they might belong to me
+    def undef_my_compiled_methods!
+      ActionView::Base::CompiledTemplates.public_instance_methods.grep(/#{Regexp.escape(method_name_without_locals)}(?:_locals_)?/).each do |m|
+        ActionView::Base::CompiledTemplates.send(:remove_method, m)
+      end
+    end
+
+  end
+end

data/lib/action_view/renderable.rb

@@ -0,0 +1,109 @@
+# 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
+
+        code = compiled_source
+        if code.sub!(/\A(#.*coding.*)\n/, '')
+          encoding_comment = $1
+        elsif defined?(Encoding) && Encoding.respond_to?(:default_external)
+          encoding_comment = "#coding:#{Encoding.default_external}"
+        end
+
+        source = <<-end_src
+          def #{render_symbol}(local_assigns)
+            old_output_buffer = output_buffer;#{locals_code};#{code}
+          ensure
+            self.output_buffer = old_output_buffer
+          end
+        end_src
+
+        if encoding_comment
+          source = "#{encoding_comment}\n#{source}"
+          line = -1
+        else
+          line = 0
+        end
+
+        begin
+          ActionView::Base::CompiledTemplates.module_eval(source, filename, line)
+        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,53 @@
+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? && !local_assigns_key?(local_assigns) && 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
+
+    private
+
+      def local_assigns_key?(local_assigns)
+        local_assigns.key?(:object) || local_assigns.key?(variable_name)
+      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)
+        new(path).tap 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