resolver.rb in actionpack-3.2.0.rc1

- old
+ new

@@ -1,7 +1,8 @@
 require "pathname"
 require "active_support/core_ext/class"
+require "active_support/core_ext/io"
 require "action_view/template"
 
 module ActionView
   # = Action View Resolver
   class Resolver
@@ -66,11 +67,11 @@
     # always check the cache before hitting the resolver. Otherwise,
     # it always hits the resolver but check if the resolver is fresher
     # before returning it.
     def cached(key, path_info, details, locals) #:nodoc:
       name, prefix, partial = path_info
-      locals = sort_locals(locals)
+      locals = locals.map { |x| x.to_s }.sort!
 
       if key && caching?
         @cached[key][name][prefix][partial][locals] ||= decorate(yield, path_info, details, locals)
       else
         fresh = decorate(yield, path_info, details, locals)
@@ -95,22 +96,10 @@
         t.locals         = locals
         t.formats        = details[:formats] || [:html] if t.formats.empty?
         t.virtual_path ||= (cached ||= build_path(*path_info))
       end
     end
-
-    if :symbol.respond_to?("<=>")
-      def sort_locals(locals) #:nodoc:
-        locals.sort.freeze
-      end
-    else
-      def sort_locals(locals) #:nodoc:
-        locals = locals.map{ |l| l.to_s }
-        locals.sort!
-        locals.freeze
-      end
-    end
   end
 
   # An abstract class that implements a Resolver with path semantics.
   class PathResolver < Resolver #:nodoc:
     EXTENSIONS = [:locale, :formats, :handlers]
@@ -128,24 +117,28 @@
       query(path, details, details[:formats])
     end
 
     def query(path, details, formats)
       query = build_query(path, details)
-      templates = []
-      sanitizer = Hash.new { |h,k| h[k] = Dir["#{File.dirname(k)}/*"] }
 
-      Dir[query].each do |p|
-        next if File.directory?(p) || !sanitizer[p].include?(p)
+      # deals with case-insensitive file systems.
+      sanitizer = Hash.new { |h,dir| h[dir] = Dir["#{dir}/*"] }
 
-        handler, format = extract_handler_and_format(p, formats)
-        contents = File.open(p, "rb") { |io| io.read }
+      template_paths = Dir[query].reject { |filename|
+        File.directory?(filename) ||
+          !sanitizer[File.dirname(filename)].include?(filename)
+      }
 
-        templates << Template.new(contents, File.expand_path(p), handler,
-          :virtual_path => path.virtual, :format => format, :updated_at => mtime(p))
-      end
+      template_paths.map { |template|
+        handler, format = extract_handler_and_format(template, formats)
+        contents = File.binread template
 
-      templates
+        Template.new(contents, File.expand_path(template), handler,
+          :virtual_path => path.virtual,
+          :format       => format,
+          :updated_at   => mtime(template))
+      }
     end
 
     # Helper for building query glob string based on resolver's pattern.
     def build_query(path, details)
       query = @pattern.dup
@@ -167,11 +160,11 @@
       entry.gsub(/[*?{}\[\]]/, '\\\\\\&')
     end
 
     # Returns the file mtime from the filesystem.
     def mtime(p)
-      File.stat(p).mtime
+      File.mtime(p)
     end
 
     # Extract handler and formats from path. If a format cannot be a found neither
     # from the path, or the handler, we should return the array of formats given
     # to the resolver.
@@ -243,16 +236,12 @@
   class OptimizedFileSystemResolver < FileSystemResolver #:nodoc:
     def build_query(path, details)
       exts = EXTENSIONS.map { |ext| details[ext] }
       query = escape_entry(File.join(@path, path))
 
-      exts.each do |ext|
-        query << "{"
-        ext.compact.uniq.each { |e| query << ".#{e}," }
-        query << "}"
-      end
-
-      query
+      query + exts.map { |ext|
+        "{#{ext.compact.uniq.map { |e| ".#{e}," }.join}}"
+      }.join
     end
   end
 
   # The same as FileSystemResolver but does not allow templates to store
   # a virtual path since it is invalid for such resolvers.