1 files changed, 50 insertions, 86 deletions

diff --git a/actionpack/lib/action_view/template/resolver.rb b/actionpack/lib/action_view/template/resolver.rb
index 8acfe6cad0..a43597e728 100644
--- a/actionpack/lib/action_view/template/resolver.rb
+++ b/actionpack/lib/action_view/template/resolver.rb
@@ -4,64 +4,47 @@ 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
+    def initialize
+      @cached = Hash.new { |h1,k1| h1[k1] =
+        Hash.new { |h2,k2| h2[k2] = Hash.new { |h3, k3| h3[k3] = {} } } }
     end
 
-    def initialize(options = {})
-      @cache  = options[:cache]
-      @cached = {}
+    def clear_cache
+      @cached.clear
     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)
+    # Normalizes the arguments and passes it on to find_template.
+    def find_all(name, prefix=nil, partial=false, details={}, key=nil)
       name, prefix = normalize_name(name, prefix)
+      details = details.merge(:handlers => default_handlers)
 
-      cached([name, details, prefix, partial]) do
-        find_templates(name, details, prefix, partial)
+      cached(key, prefix, name, partial) do
+        find_templates(name, prefix, partial, details)
       end
     end
 
   private
 
+    def caching?
+      @caching ||= !defined?(Rails.application) || Rails.application.config.cache_classes
+    end
+
+    def default_handlers
+      Template::Handlers.extensions + [nil]
+    end
+
     # 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)
+    def find_templates(name, prefix, partial, details)
       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.
@@ -73,92 +56,73 @@ module ActionView
       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
+    def cached(key, prefix, name, partial)
+      return yield unless key && caching?
+      scope = @cached[key][prefix][name]
+      if scope.key?(partial)
+        scope[partial]
+      else
+        scope[partial] = yield
+      end
     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
+    alias :to_path :to_s
 
   private
 
-    def build_path(name, details, prefix, partial)
+    def find_templates(name, prefix, partial, details)
+      path = build_path(name, prefix, partial, details)
+      query(partial, path, EXTENSION_ORDER.map { |ext| details[ext] })
+    end
+
+    def build_path(name, prefix, partial, details)
       path = ""
       path << "#{prefix}/" unless prefix.empty?
       path << (partial ? "_#{name}" : name)
       path
     end
 
-    def query(path, exts)
+    def query(partial, 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))
+        handler, format = extract_handler_and_format(p)
+        Template.new(File.read(p), File.expand_path(p), handler,
+          :partial => partial, :virtual_path => path, :format => format)
       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])
+    def extract_handler_and_format(path)
+      pieces = File.basename(path).split(".")
+      pieces.shift
 
-        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
+      handler = Template.handler_class_for_extension(pieces.pop)
+      format  = pieces.last && Mime[pieces.last] && pieces.pop.to_sym
+      [handler, format]
     end
   end
 
   class FileSystemResolver < PathResolver
-    def initialize(path, options = {})
+    def initialize(path)
       raise ArgumentError, "path already is a Resolver class" if path.is_a?(Resolver)
-      super(options)
+      super()
       @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
+    def eql?(resolver)
+      self.class.equal?(resolver.class) && to_path == resolver.to_path
     end
+    alias :== :eql?
   end
 end