actionpack 2.0.5 → 2.1.0

data/lib/action_controller/test_case.rb

@@ -16,7 +16,30 @@ module ActionController
   end
 
   class TestCase < ActiveSupport::TestCase
+    # When the request.remote_addr remains the default for testing, which is 0.0.0.0, the exception is simply raised inline
+    # (bystepping the regular exception handling from rescue_action). If the request.remote_addr is anything else, the regular
+    # rescue_action process takes place. This means you can test your rescue_action code by setting remote_addr to something else
+    # than 0.0.0.0.
+    #
+    # The exception is stored in the exception accessor for further inspection.
+    module RaiseActionExceptions
+      attr_accessor :exception
+
+      def rescue_action(e)
+        self.exception = e
+        
+        if request.remote_addr == "0.0.0.0"
+          raise(e)
+        else
+          super(e)
+        end
+      end
+    end
+
+    setup :setup_controller_request_and_response
+
     @@controller_class = nil
+
     class << self
       def tests(controller_class)
         self.controller_class = controller_class
@@ -31,7 +54,7 @@ module ActionController
         if current_controller_class = read_inheritable_attribute(:controller_class)
           current_controller_class
         else
-          self.controller_class= determine_default_controller_class(name)
+          self.controller_class = determine_default_controller_class(name)
         end
       end
 
@@ -42,32 +65,19 @@ module ActionController
       end
 
       def prepare_controller_class(new_class)
-        new_class.class_eval do
-          def rescue_action(e)
-            raise e
-          end
-        end
+        new_class.send :include, RaiseActionExceptions
       end
     end
 
-    def setup_with_controller
+    def setup_controller_request_and_response
       @controller = self.class.controller_class.new
-      @request    = TestRequest.new
-      @response   = TestResponse.new
+      @controller.request = @request = TestRequest.new
+      @response = TestResponse.new
     end
-    alias_method :setup, :setup_with_controller
-
-    def self.method_added(method)
-      if method.to_s == 'setup'
-        unless method_defined?(:setup_without_controller)
-          alias_method :setup_without_controller, :setup
-          define_method(:setup) do
-            setup_with_fixtures if respond_to?(:setup_with_fixtures)
-            setup_with_controller
-            setup_without_controller
-          end
-        end
-      end
+    
+    # Cause the action to be rescued according to the regular rules for rescue_action when the visitor is not local
+    def rescue_action_in_public!
+      @request.remote_addr = '208.77.188.166' # example.com
     end
  end
-end
+end

data/lib/action_controller/test_process.rb

@@ -1,8 +1,9 @@
 require 'action_controller/assertions'
+require 'action_controller/test_case'
 
 module ActionController #:nodoc:
   class Base
-    # Process a test request called with a +TestRequest+ object.
+    # Process a test request called with a TestRequest object.
     def self.process_test(request)
       new.process_test(request)
     end
@@ -48,7 +49,7 @@ module ActionController #:nodoc:
     # Either the RAW_POST_DATA environment variable or the URL-encoded request
     # parameters.
     def raw_post
-      env['RAW_POST_DATA'] ||= url_encoded_request_parameters
+      env['RAW_POST_DATA'] ||= returning(url_encoded_request_parameters) { |b| b.force_encoding(Encoding::BINARY) if b.respond_to?(:force_encoding) }
     end
 
     def port=(number)
@@ -154,12 +155,12 @@ module ActionController #:nodoc:
   # A refactoring of TestResponse to allow the same behavior to be applied
   # to the "real" CgiResponse class in integration tests.
   module TestResponseBehavior #:nodoc:
-    # the response code of the request
+    # The response code of the request
     def response_code
       headers['Status'][0,3].to_i rescue 0
     end
     
-    # returns a String to ensure compatibility with Net::HTTPResponse
+    # Returns a String to ensure compatibility with Net::HTTPResponse
     def code
       headers['Status'].to_s.split(' ')[0]
     end
@@ -168,34 +169,34 @@ module ActionController #:nodoc:
       headers['Status'].to_s.split(' ',2)[1]
     end
 
-    # was the response successful?
+    # Was the response successful?
     def success?
       response_code == 200
     end
 
-    # was the URL not found?
+    # Was the URL not found?
     def missing?
       response_code == 404
     end
 
-    # were we redirected?
+    # Were we redirected?
     def redirect?
       (300..399).include?(response_code)
     end
 
-    # was there a server-side error?
+    # Was there a server-side error?
     def error?
       (500..599).include?(response_code)
     end
 
     alias_method :server_error?, :error?
 
-    # returns the redirection location or nil
+    # Returns the redirection location or nil
     def redirect_url
       headers['Location']
     end
 
-    # does the redirect location match this regexp pattern?
+    # Does the redirect location match this regexp pattern?
     def redirect_url_match?( pattern )
       return false if redirect_url.nil?
       p = Regexp.new(pattern) if pattern.class == String
@@ -204,7 +205,7 @@ module ActionController #:nodoc:
       p.match(redirect_url) != nil
     end
 
-    # returns the template path of the file which was used to
+    # Returns the template path of the file which was used to
     # render this response (or nil) 
     def rendered_file(with_controller=false)
       unless template.first_render.nil?
@@ -216,50 +217,49 @@ module ActionController #:nodoc:
       end
     end
 
-    # was this template rendered by a file?
+    # Was this template rendered by a file?
     def rendered_with_file?
       !rendered_file.nil?
     end
 
-    # a shortcut to the flash (or an empty hash if no flash.. hey! that rhymes!)
+    # A shortcut to the flash. Returns an empyt hash if no session flash exists.
     def flash
       session['flash'] || {}
     end
 
-    # do we have a flash? 
+    # Do we have a flash?
     def has_flash?
       !session['flash'].empty?
     end
 
-    # do we have a flash that has contents?
+    # Do we have a flash that has contents?
     def has_flash_with_contents?
       !flash.empty?
     end
 
-    # does the specified flash object exist?
+    # Does the specified flash object exist?
     def has_flash_object?(name=nil)
       !flash[name].nil?
     end
 
-    # does the specified object exist in the session?
+    # Does the specified object exist in the session?
     def has_session_object?(name=nil)
       !session[name].nil?
     end
 
-    # a shortcut to the template.assigns
+    # A shortcut to the template.assigns
     def template_objects
       template.assigns || {}
     end
 
-    # does the specified template object exist? 
+    # Does the specified template object exist?
     def has_template_object?(name=nil)
       !template_objects[name].nil?      
     end
 
     # Returns the response cookies, converted to a Hash of (name => CGI::Cookie) pairs
-    # Example:
     # 
-    # assert_equal ['AuthorOfNewPage'], r.cookies['author'].value
+    #   assert_equal ['AuthorOfNewPage'], r.cookies['author'].value
     def cookies
       headers['cookie'].inject({}) { |hash, cookie| hash[cookie.name] = cookie; hash }
     end
@@ -340,6 +340,7 @@ module ActionController #:nodoc:
       @content_type = content_type
       @original_filename = path.sub(/^.*#{File::SEPARATOR}([^#{File::SEPARATOR}]+)$/) { $1 }
       @tempfile = Tempfile.new(@original_filename)
+      @tempfile.set_encoding(Encoding::BINARY) if @tempfile.respond_to?(:set_encoding)
       @tempfile.binmode if binary
       FileUtils.copy_file(path, @tempfile.path)
     end
@@ -357,7 +358,7 @@ module ActionController #:nodoc:
 
   module TestProcess
     def self.included(base)
-      # execute the request simulating a specific http method and set/volley the response
+      # execute the request simulating a specific HTTP method and set/volley the response
       %w( get post put delete head ).each do |method|
         base.class_eval <<-EOV, __FILE__, __LINE__
           def #{method}(action, parameters = nil, session = nil, flash = nil)
@@ -373,7 +374,7 @@ module ActionController #:nodoc:
       # Sanity check for required instance variables so we can give an
       # understandable error message.
       %w(@controller @request @response).each do |iv_name|
-        if !(instance_variables.include?(iv_name) || instance_variables.include?(iv_name.to_sym)) || instance_variable_get(iv_name).nil?
+        if !(instance_variable_names.include?(iv_name) || instance_variable_names.include?(iv_name.to_sym)) || instance_variable_get(iv_name).nil?
           raise "#{iv_name} is nil: make sure you set it in your test's setup method."
         end
       end
@@ -464,10 +465,13 @@ module ActionController #:nodoc:
       return super
     end
     
-    # Shortcut for ActionController::TestUploadedFile.new(Test::Unit::TestCase.fixture_path + path, type). Example:
+    # Shortcut for <tt>ActionController::TestUploadedFile.new(Test::Unit::TestCase.fixture_path + path, type)</tt>:
+    #
     #   post :change_avatar, :avatar => fixture_file_upload('/files/spongebob.png', 'image/png')
     #
-    # To upload binary files on Windows, pass :binary as the last parameter. This will not affect other platforms.
+    # To upload binary files on Windows, pass <tt>:binary</tt> as the last parameter.
+    # This will not affect other platforms:
+    #
     #   post :change_avatar, :avatar => fixture_file_upload('/files/spongebob.png', 'image/png', :binary)
     def fixture_file_upload(path, mime_type = nil, binary = false)
       ActionController::TestUploadedFile.new(
@@ -482,17 +486,17 @@ module ActionController #:nodoc:
     # with a new RouteSet instance. 
     #
     # The new instance is yielded to the passed block. Typically the block
-    # will create some routes using map.draw { map.connect ... }:
+    # will create some routes using <tt>map.draw { map.connect ... }</tt>:
     #
-    #  with_routing do |set|
-    #    set.draw do |map|
-    #      map.connect ':controller/:action/:id'
-    #        assert_equal(
-    #          ['/content/10/show', {}],
-    #          map.generate(:controller => 'content', :id => 10, :action => 'show')
-    #      end
-    #    end
-    #  end
+    #   with_routing do |set|
+    #     set.draw do |map|
+    #       map.connect ':controller/:action/:id'
+    #         assert_equal(
+    #           ['/content/10/show', {}],
+    #           map.generate(:controller => 'content', :id => 10, :action => 'show')
+    #       end
+    #     end
+    #   end
     #
     def with_routing
       real_routes = ActionController::Routing::Routes

data/lib/action_controller/url_rewriter.rb

@@ -15,8 +15,8 @@ module ActionController
   # In addition to providing +url_for+, named routes are also accessible after
   # including UrlWriter.
   module UrlWriter
-    # The default options for urls written by this writer. Typically a :host pair
-    # is provided.
+    # The default options for urls written by this writer. Typically a <tt>:host</tt>
+    # pair is provided.
     mattr_accessor :default_url_options
     self.default_url_options = {}
 
@@ -29,20 +29,25 @@ module ActionController
     # Generate a url based on the options provided, default_url_options and the
     # routes defined in routes.rb.  The following options are supported:
     #
-    # * <tt>:only_path</tt> If true, the relative url is returned. Defaults to false.
-    # * <tt>:protocol</tt> The protocol to connect to. Defaults to 'http'.
-    # * <tt>:host</tt> Specifies the host the link should be targetted at. If <tt>:only_path</tt> is false, this option must be
-    #   provided either explicitly, or via default_url_options.
-    # * <tt>:port</tt> Optionally specify the port to connect to.
-    # * <tt>:anchor</tt> An anchor name to be appended to the path.
-    # * <tt>:skip_relative_url_root</tt> If true, the url is not constructed using the relative_url_root set in <tt>ActionController::AbstractRequest.relative_url_root</tt>.
+    # * <tt>:only_path</tt> - If true, the relative url is returned. Defaults to +false+.
+    # * <tt>:protocol</tt> - The protocol to connect to. Defaults to 'http'.
+    # * <tt>:host</tt> - Specifies the host the link should be targetted at.
+    #   If <tt>:only_path</tt> is false, this option must be
+    #   provided either explicitly, or via +default_url_options+.
+    # * <tt>:port</tt> - Optionally specify the port to connect to.
+    # * <tt>:anchor</tt> - An anchor name to be appended to the path.
+    # * <tt>:skip_relative_url_root</tt> - If true, the url is not constructed using the
+    #   +relative_url_root+ set in ActionController::AbstractRequest.relative_url_root.
+    # * <tt>:trailing_slash</tt> - If true, adds a trailing slash, as in "/archive/2009/"
     #
-    # Any other key(:controller, :action, etc...) given to <tt>url_for</tt> is forwarded to the Routes module.
+    # Any other key (<tt>:controller</tt>, <tt>:action</tt>, etc.) given to
+    # +url_for+ is forwarded to the Routes module.
     #
     # Examples:
     #
     #    url_for :controller => 'tasks', :action => 'testing', :host=>'somehost.org', :port=>'8080'    # => 'http://somehost.org:8080/tasks/testing'
     #    url_for :controller => 'tasks', :action => 'testing', :host=>'somehost.org', :anchor => 'ok', :only_path => true    # => '/tasks/testing#ok'
+    #    url_for :controller => 'tasks', :action => 'testing', :trailing_slash=>true  # => 'http://somehost.org/tasks/testing/'
     #    url_for :controller => 'tasks', :action => 'testing', :host=>'somehost.org', :number => '33'  # => 'http://somehost.org/tasks/testing?number=33'
     def url_for(options)
       options = self.class.default_url_options.merge(options)
@@ -61,10 +66,11 @@ module ActionController
         # Delete the unused options to prevent their appearance in the query string.
         [:protocol, :host, :port, :skip_relative_url_root].each { |k| options.delete(k) }
       end
-
+      trailing_slash = options.delete(:trailing_slash) if options.key?(:trailing_slash)
       url << ActionController::AbstractRequest.relative_url_root.to_s unless options[:skip_relative_url_root]
       anchor = "##{CGI.escape options.delete(:anchor).to_param.to_s}" if options[:anchor]
-      url << Routing::Routes.generate(options, {})
+      generated = Routing::Routes.generate(options, {})
+      url << (trailing_slash ? generated.sub(/\?|\z/) { "/" + $& } : generated)
       url << anchor if anchor
 
       url

data/lib/action_controller/vendor/html-scanner/html/tokenizer.rb

@@ -54,7 +54,7 @@ module HTML #:nodoc:
           tag << (@scanner.scan_until(/--\s*>/) || @scanner.scan_until(/\Z/))
         elsif @scanner.scan(/!\[CDATA\[/)
           tag << @scanner.matched
-          tag << @scanner.scan_until(/\]\]>/)
+          tag << (@scanner.scan_until(/\]\]>/) || @scanner.scan_until(/\Z/))
         elsif @scanner.scan(/!/) # doctype
           tag << @scanner.matched
           tag << consume_quoted_regions

data/lib/action_pack.rb

@@ -1,5 +1,5 @@
 #--
-# Copyright (c) 2004-2007 David Heinemeier Hansson
+# Copyright (c) 2004-2008 David Heinemeier Hansson
 #
 # Permission is hereby granted, free of charge, to any person obtaining
 # a copy of this software and associated documentation files (the

data/lib/action_pack/version.rb

@@ -1,8 +1,8 @@
 module ActionPack #:nodoc:
   module VERSION #:nodoc:
     MAJOR = 2
-    MINOR = 0
-    TINY  = 5
+    MINOR = 1
+    TINY  = 0
 
     STRING = [MAJOR, MINOR, TINY].join('.')
   end

data/lib/action_view.rb

@@ -1,5 +1,5 @@
 #--
-# Copyright (c) 2004-2007 David Heinemeier Hansson
+# Copyright (c) 2004-2008 David Heinemeier Hansson
 #
 # Permission is hereby granted, free of charge, to any person obtaining
 # a copy of this software and associated documentation files (the
@@ -22,16 +22,24 @@
 #++
 
 require 'action_view/template_handler'
+require 'action_view/template_handlers/compilable'
 require 'action_view/template_handlers/builder'
 require 'action_view/template_handlers/erb'
 require 'action_view/template_handlers/rjs'
 
+require 'action_view/template_finder'
+require 'action_view/template'
+require 'action_view/partial_template'
+require 'action_view/inline_template'
+
 require 'action_view/base'
 require 'action_view/partials'
 require 'action_view/template_error'
 
 ActionView::Base.class_eval do
   include ActionView::Partials
-end
 
-ActionView::Base.load_helpers
+  ActionView::Base.helper_modules.each do |helper_module|
+    include helper_module
+  end
+end

data/lib/action_view/base.rb

@@ -1,10 +1,13 @@
 module ActionView #:nodoc:
   class ActionViewError < StandardError #:nodoc:
   end
+  
+  class MissingTemplate < ActionViewError #:nodoc:
+  end
 
-  # Action View templates can be written in three ways. If the template file has a +.erb+ (or +.rhtml+) extension then it uses a mixture of ERb 
-  # (included in Ruby) and HTML. If the template file has a +.builder+ (or +.rxml+) extension then Jim Weirich's Builder::XmlMarkup library is used. 
-  # If the template file has a +.rjs+ extension then it will use ActionView::Helpers::PrototypeHelper::JavaScriptGenerator.
+  # Action View templates can be written in three ways. If the template file has a <tt>.erb</tt> (or <tt>.rhtml</tt>) extension then it uses a mixture of ERb 
+  # (included in Ruby) and HTML. If the template file has a <tt>.builder</tt> (or <tt>.rxml</tt>) extension then Jim Weirich's Builder::XmlMarkup library is used. 
+  # If the template file has a <tt>.rjs</tt> extension then it will use ActionView::Helpers::PrototypeHelper::JavaScriptGenerator.
   # 
   # = ERb
   # 
@@ -21,7 +24,7 @@ module ActionView #:nodoc:
   #
   #   Hi, Mr. <% puts "Frodo" %>
   #
-  # If you absolutely must write from within a function, you can use the TextHelper#concat
+  # If you absolutely must write from within a function, you can use the TextHelper#concat.
   #
   # <%- and -%> suppress leading and trailing whitespace, including the trailing newline, and can be used interchangeably with <% and %>.
   #
@@ -43,7 +46,7 @@ module ActionView #:nodoc:
   #   <% @page_title = "A Wonderful Hello" %>
   #   <%= render "shared/header" %>
   #
-  # Now the header can pick up on the @page_title variable and use it for outputting a title tag:
+  # Now the header can pick up on the <tt>@page_title</tt> variable and use it for outputting a title tag:
   #
   #   <title><%= @page_title %></title>
   #
@@ -53,7 +56,7 @@ module ActionView #:nodoc:
   #
   #   <%= render "shared/header", { :headline => "Welcome", :person => person } %>
   #
-  # These can now be accessed in shared/header with:
+  # These can now be accessed in <tt>shared/header</tt> with:
   #
   #   Headline: <%= headline %>
   #   First name: <%= person.first_name %>
@@ -74,13 +77,13 @@ module ActionView #:nodoc:
   #
   # == Builder
   #
-  # Builder templates are a more programmatic alternative to ERb. They are especially useful for generating XML content. An +XmlMarkup+ object 
-  # named +xml+ is automatically made available to templates with a +.builder+ extension. 
+  # Builder templates are a more programmatic alternative to ERb. They are especially useful for generating XML content. An XmlMarkup object 
+  # named +xml+ is automatically made available to templates with a <tt>.builder</tt> extension. 
   #
   # Here are some basic examples:
   #
   #   xml.em("emphasized")                              # => <em>emphasized</em>
-  #   xml.em { xml.b("emph & bold") }                    # => <em><b>emph &amp; bold</b></em>
+  #   xml.em { xml.b("emph & bold") }                   # => <em><b>emph &amp; bold</b></em>
   #   xml.a("A Link", "href"=>"http://onestepback.org") # => <a href="http://onestepback.org">A Link</a>
   #   xml.target("name"=>"compile", "option"=>"fast")   # => <target option="fast" name="compile"\>
   #                                                     # NOTE: order of attributes is not specified.
@@ -127,18 +130,18 @@ module ActionView #:nodoc:
   #
   # == JavaScriptGenerator
   #
-  # JavaScriptGenerator templates end in +.rjs+. Unlike conventional templates which are used to 
+  # JavaScriptGenerator templates end in <tt>.rjs</tt>. Unlike conventional templates which are used to 
   # render the results of an action, these templates generate instructions on how to modify an already rendered page. This makes it easy to 
   # modify multiple elements on your page in one declarative Ajax response. Actions with these templates are called in the background with Ajax 
   # and make updates to the page where the request originated from.
   # 
   # An instance of the JavaScriptGenerator object named +page+ is automatically made available to your template, which is implicitly wrapped in an ActionView::Helpers::PrototypeHelper#update_page block. 
   #
-  # When an .rjs action is called with +link_to_remote+, the generated JavaScript is automatically evaluated.  Example:
+  # When an <tt>.rjs</tt> action is called with +link_to_remote+, the generated JavaScript is automatically evaluated.  Example:
   #
   #   link_to_remote :url => {:action => 'delete'}
   #
-  # The subsequently rendered +delete.rjs+ might look like:
+  # The subsequently rendered <tt>delete.rjs</tt> might look like:
   #
   #   page.replace_html  'sidebar', :partial => 'sidebar'
   #   page.remove        "person-#{@person.id}"
@@ -150,16 +153,12 @@ module ActionView #:nodoc:
   class Base
     include ERB::Util
 
-    attr_reader   :first_render
-    attr_accessor :base_path, :assigns, :template_extension
-    attr_accessor :controller, :view_paths
-
-    attr_reader :logger, :response, :headers
-    attr_internal :cookies, :flash, :headers, :params, :request, :response, :session
-    
-    delegate :logger, :action_name, :to => :controller
+    attr_reader   :finder
+    attr_accessor :base_path, :assigns, :template_extension, :first_render
+    attr_accessor :controller
     
     attr_writer :template_format
+    attr_accessor :current_render_extension
 
     # Specify trim mode for the ERB compiler. Defaults to '-'.
     # See ERb documentation for suitable values.
@@ -169,18 +168,12 @@ module ActionView #:nodoc:
     # Specify whether file modification times should be checked to see if a template needs recompilation
     @@cache_template_loading = false
     cattr_accessor :cache_template_loading
-
-    # Specify whether file extension lookup should be cached, and whether template base path lookup should be cached.
-    # Should be +false+ for development environments. Defaults to +true+.
-    @@cache_template_extensions = true
-    cattr_accessor :cache_template_extensions
-
-    # Specify whether local_assigns should be able to use string keys.
-    # Defaults to +true+. String keys are deprecated and will be removed
-    # shortly.
-    @@local_assigns_support_string_keys = true
-    cattr_accessor :local_assigns_support_string_keys
     
+    def self.cache_template_extensions=(*args)
+      ActiveSupport::Deprecation.warn("config.action_view.cache_template_extensions option has been deprecated and has no affect. " <<
+                                       "Please remove it from your config files.", caller)
+    end
+
     # Specify whether RJS responses should be wrapped in a try/catch block
     # that alert()s the caught exception (and then re-raises it). 
     @@debug_rjs = false
@@ -189,89 +182,47 @@ module ActionView #:nodoc:
     @@erb_variable = '_erbout'
     cattr_accessor :erb_variable
     
-    delegate :request_forgery_protection_token, :to => :controller
+    attr_internal :request
 
-    @@template_handlers = HashWithIndifferentAccess.new
+    delegate :request_forgery_protection_token, :template, :params, :session, :cookies, :response, :headers,
+             :flash, :logger, :action_name, :to => :controller
  
     module CompiledTemplates #:nodoc:
       # holds compiled template code
     end
     include CompiledTemplates
 
-    # Maps inline templates to their method names 
+    # Maps inline templates to their method names
+    cattr_accessor :method_names
     @@method_names = {}
-    # Map method names to their compile time
-    @@compile_time = {}
     # Map method names to the names passed in local assigns so far
     @@template_args = {}
-    # Count the number of inline templates
-    @@inline_template_count = 0
-    # Maps template paths without extension to their file extension returned by pick_template_extension.
-    # If for a given path, path.ext1 and path.ext2 exist on the file system, the order of extensions
-    # used by pick_template_extension determines whether ext1 or ext2 will be stored.
-    @@cached_template_extension = {}
-    # Maps template paths / extensions to 
-    @@cached_base_paths = {}
 
     # Cache public asset paths
     cattr_reader :computed_public_paths
     @@computed_public_paths = {}
 
-    @@template_handlers = {}
-    @@default_template_handlers = nil
-
     class ObjectWrapper < Struct.new(:value) #:nodoc:
     end
 
-    def self.load_helpers #:nodoc:
-      Dir.entries("#{File.dirname(__FILE__)}/helpers").sort.each do |file|
+    def self.helper_modules #:nodoc:
+      helpers = []
+      Dir.entries(File.expand_path("#{File.dirname(__FILE__)}/helpers")).sort.each do |file|
         next unless file =~ /^([a-z][a-z_]*_helper).rb$/
         require "action_view/helpers/#{$1}"
         helper_module_name = $1.camelize
         if Helpers.const_defined?(helper_module_name)
-          include Helpers.const_get(helper_module_name)
+          helpers << Helpers.const_get(helper_module_name)
         end
       end
+      return helpers
     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 self.register_template_handler(extension, klass)
-      @@template_handlers[extension.to_sym] = klass
-    end
-
-    def self.template_handler_extensions
-      @@template_handler_extensions ||= @@template_handlers.keys.map(&:to_s).sort
-    end
-
-    def self.register_default_template_handler(extension, klass)
-      register_template_handler(extension, klass)
-      @@default_template_handlers = klass
-    end
-
-    def self.handler_for_extension(extension)
-      (extension && @@template_handlers[extension.to_sym]) || @@default_template_handlers
-    end
-
-    register_default_template_handler :erb, TemplateHandlers::ERB
-    register_template_handler :rjs, TemplateHandlers::RJS
-    register_template_handler :builder, TemplateHandlers::Builder
-
-    # TODO: Depreciate old template extensions
-    register_template_handler :rhtml, TemplateHandlers::ERB
-    register_template_handler :rxml, TemplateHandlers::Builder
-
     def initialize(view_paths = [], assigns_for_first_render = {}, controller = nil)#:nodoc:
-      @view_paths = view_paths.respond_to?(:find) ? view_paths.dup : [*view_paths].compact
       @assigns = assigns_for_first_render
       @assigns_added = nil
       @controller = controller
-      @logger = controller && controller.logger 
+      @finder = TemplateFinder.new(self, view_paths)
     end
 
     # Renders the template present at <tt>template_path</tt>. If <tt>use_full_path</tt> is set to true, 
@@ -291,61 +242,27 @@ If you are rendering a subtemplate, you must now use controller-like partial syn
         END_ERROR
       end
       
-      @first_render ||= template_path
-      template_path_without_extension, template_extension = path_and_extension(template_path)
-      if use_full_path
-        if template_extension
-          template_file_name = full_template_path(template_path_without_extension, template_extension)
-        else
-          template_extension = pick_template_extension(template_path).to_s
-          unless template_extension
-            raise ActionViewError, "No template found for #{template_path} in #{view_paths.inspect}"
-          end
-          template_file_name = full_template_path(template_path, template_extension)
-          template_extension = template_extension.gsub(/^.+\./, '') # strip off any formats
-        end
-      else
-        template_file_name = template_path
-      end
-
-      template_source = nil # Don't read the source until we know that it is required
-
-      if template_file_name.blank?
-        raise ActionViewError, "Couldn't find template file for #{template_path} in #{view_paths.inspect}"
-      end
-
-      begin
-        render_template(template_extension, template_source, template_file_name, local_assigns)
-      rescue Exception => e
-        if TemplateError === e
-          e.sub_template_of(template_file_name)
-          raise e
-        else
-          raise TemplateError.new(find_base_path_for("#{template_path_without_extension}.#{template_extension}") || view_paths.first, template_file_name, @assigns, template_source, e)
-        end
-      end
+      Template.new(self, template_path, use_full_path, local_assigns).render_template
     end
     
     # Renders the template present at <tt>template_path</tt> (relative to the view_paths array). 
     # The hash in <tt>local_assigns</tt> is made available as local variables.
-    def render(options = {}, old_local_assigns = {}, &block) #:nodoc:
+    def render(options = {}, local_assigns = {}, &block) #:nodoc:
       if options.is_a?(String)
-        render_file(options, true, old_local_assigns)
+        render_file(options, true, local_assigns)
       elsif options == :update
         update_page(&block)
       elsif options.is_a?(Hash)
         options = options.reverse_merge(:locals => {}, :use_full_path => true)
 
-        if options[:layout]
-          path, partial_name = partial_pieces(options.delete(:layout))
-
+        if partial_layout = options.delete(:layout)
           if block_given?
             wrap_content_for_layout capture(&block) do 
-              concat(render(options.merge(:partial => "#{path}/#{partial_name}")), block.binding)
+              concat(render(options.merge(:partial => partial_layout)), block.binding)
             end
           else
             wrap_content_for_layout render(options) do
-              render(options.merge(:partial => "#{path}/#{partial_name}"))
+              render(options.merge(:partial => partial_layout))
             end
           end
         elsif options[:file]
@@ -355,61 +272,14 @@ If you are rendering a subtemplate, you must now use controller-like partial syn
         elsif options[:partial]
           render_partial(options[:partial], ActionView::Base::ObjectWrapper.new(options[:object]), options[:locals])
         elsif options[:inline]
-          render_template(options[:type], options[:inline], nil, options[:locals])
+          template = InlineTemplate.new(self, options[:inline], options[:locals], options[:type])
+          render_template(template)
         end
       end
     end
 
-    # Renders the +template+ which is given as a string as either erb or builder depending on <tt>template_extension</tt>.
-    # The hash in <tt>local_assigns</tt> is made available as local variables.
-    def render_template(template_extension, template, file_path = nil, local_assigns = {}) #:nodoc:
-      handler = self.class.handler_for_extension(template_extension)
-
-      if template_handler_is_compilable?(handler)
-        compile_and_render_template(handler, template, file_path, local_assigns)
-      else
-        template ||= read_template_file(file_path, template_extension) # Make sure that a lazyily-read template is loaded.
-        delegate_render(handler, template, local_assigns)
-      end
-    end
-
-    # Gets the full template path with base path for the given template_path and extension.
-    #
-    #   full_template_path('users/show', 'html.erb')
-    #   # => '~/rails/app/views/users/show.html.erb
-    #
-    def full_template_path(template_path, extension)
-      if @@cache_template_extensions
-        (@@cached_base_paths[template_path] ||= {})[extension.to_s] ||= find_full_template_path(template_path, extension)
-      else
-        find_full_template_path(template_path, extension)
-      end
-    end
-
-    # Gets the extension for an existing template with the given template_path.
-    # Returns the format with the extension if that template exists.
-    #
-    #   pick_template_extension('users/show')
-    #   # => 'html.erb'
-    #
-    #   pick_template_extension('users/legacy')
-    #   # => "rhtml"
-    #
-    def pick_template_extension(template_path)#:nodoc:
-      if @@cache_template_extensions
-        (@@cached_template_extension[template_path] ||= {})[template_format] ||= find_template_extension_for(template_path)
-      else
-        find_template_extension_for(template_path)
-      end
-    end
-
-    def file_exists?(template_path)#:nodoc:
-      template_file_name, template_file_extension = path_and_extension(template_path)
-      if template_file_extension
-        template_exists?(template_file_name, template_file_extension)
-      else
-        template_exists?(template_file_name, pick_template_extension(template_path))
-      end
+    def render_template(template) #:nodoc:
+      template.render_template
     end
 
     # Returns true is the file may be rendered implicitly.
@@ -417,31 +287,31 @@ If you are rendering a subtemplate, you must now use controller-like partial syn
       template_path.split('/').last[0,1] != '_'
     end
 
-    # symbolized version of the :format parameter of the request, or :html by default.
+    # Returns a symbolized version of the <tt>:format</tt> parameter of the request,
+    # or <tt>:html</tt> by default.
+    #
+    # EXCEPTION: If the <tt>:format</tt> parameter is not set, the Accept header will be examined for
+    # whether it contains the JavaScript mime type as its first priority. If that's the case,
+    # it will be used. This ensures that Ajax applications can use the same URL to support both
+    # JavaScript and non-JavaScript users.
     def template_format
       return @template_format if @template_format
-      format = controller && controller.respond_to?(:request) && controller.request.parameters[:format]
-      @template_format = format.blank? ? :html : format.to_sym
-    end
 
-    # Adds a view_path to the front of the view_paths array.
-    # This change affects the current request only.
-    #
-    #   @template.prepend_view_path("views/default")
-    #   @template.prepend_view_path(["views/default", "views/custom"])
-    #
-    def prepend_view_path(path)
-      @view_paths.unshift(*path)
-    end
-    
-    # Adds a view_path to the end of the view_paths array.
-    # This change affects the current request only.
-    #
-    #   @template.append_view_path("views/default")
-    #   @template.append_view_path(["views/default", "views/custom"])
-    #
-    def append_view_path(path)
-      @view_paths.push(*path)
+      if controller && controller.respond_to?(:request)
+        parameter_format = controller.request.parameters[:format]
+        accept_format    = controller.request.accepts.first
+
+        case
+        when parameter_format.blank? && accept_format != :js
+          @template_format = :html
+        when parameter_format.blank? && accept_format == :js
+          @template_format = :js
+        else
+          @template_format = parameter_format.to_sym
+        end
+      else
+        @template_format = :html
+      end
     end
 
     private
@@ -450,62 +320,6 @@ If you are rendering a subtemplate, you must now use controller-like partial syn
         @content_for_layout = content
         returning(yield) { @content_for_layout = original_content_for_layout }
       end
-  
-      def find_full_template_path(template_path, extension)
-        file_name = "#{template_path}.#{extension}"
-        base_path = find_base_path_for(file_name)
-        base_path.blank? ? "" : "#{base_path}/#{file_name}"
-      end
-
-      # Asserts the existence of a template.
-      def template_exists?(template_path, extension)
-        file_path = full_template_path(template_path, extension)
-        !file_path.blank? && @@method_names.has_key?(file_path) || File.exist?(file_path)
-      end
-
-      # Splits the path and extension from the given template_path and returns as an array.
-      def path_and_extension(template_path)
-        template_path_without_extension = template_path.sub(/\.(\w+)$/, '')
-        [ template_path_without_extension, $1 ]
-      end
-      
-      # Returns the view path that contains the given relative template path.
-      def find_base_path_for(template_file_name)
-        view_paths.find { |p| File.file?(File.join(p, template_file_name)) }
-      end
-
-      # Returns the view path that the full path resides in.
-      def extract_base_path_from(full_path)
-        view_paths.find { |p| full_path[0..p.size - 1] == p }
-      end
-
-      # Determines the template's file extension, such as rhtml, rxml, or rjs.
-      def find_template_extension_for(template_path)
-        find_template_extension_from_handler(template_path, true) ||
-        find_template_extension_from_handler(template_path) ||
-        find_template_extension_from_first_render()
-      end
-
-      def find_template_extension_from_handler(template_path, formatted = nil)
-        checked_template_path = formatted ? "#{template_path}.#{template_format}" : template_path
-
-        self.class.template_handler_extensions.each do |extension|
-          if template_exists?(checked_template_path, extension)
-            return formatted ? "#{template_format}.#{extension}" : extension.to_s
-          end
-        end
-        nil
-      end
-      
-      # Determine the template extension from the <tt>@first_render</tt> filename
-      def find_template_extension_from_first_render
-        File.basename(@first_render.to_s)[/^[^.]+\.(.+)$/, 1]
-      end
-
-      # This method reads a template file.
-      def read_template_file(template_path, extension)
-        File.read(template_path)
-      end
 
       # Evaluate the local assigns and pushes them to the view.
       def evaluate_assigns
@@ -515,146 +329,15 @@ If you are rendering a subtemplate, you must now use controller-like partial syn
         end
       end
 
-      def delegate_render(handler, template, local_assigns)
-        handler.new(self).render(template, local_assigns)
-      end
-
-      def delegate_compile(handler, template)
-        handler.new(self).compile(template)
-      end
-
-      def template_handler_is_compilable?(handler)
-        handler.new(self).respond_to?(:compile)
-      end
-      
       # Assigns instance variables from the controller to the view.
       def assign_variables_from_controller
-        @assigns.each do |key, value|
-          if ['logger'].include?(key)
-            instance_variable_set("@#{key}", ActiveSupport::Deprecation::DeprecatedInstanceVariableProxy.new(self, key.to_sym))
-          elsif ['action_name'].include?(key)
-            instance_variable_set("@#{key}", ActiveSupport::Deprecation::DeprecatedInstanceVariable.new(value, key))
-          else
-            instance_variable_set("@#{key}", value)
-          end
-        end
-      end
-
-
-      # Return true if the given template was compiled for a superset of the keys in local_assigns
-      def supports_local_assigns?(render_symbol, local_assigns)
-        local_assigns.empty? ||
-          ((args = @@template_args[render_symbol]) && local_assigns.all? { |k,_| args.has_key?(k) })
+        @assigns.each { |key, value| instance_variable_set("@#{key}", value) }
       end
-
-      # Method to check whether template compilation is necessary.
-      # The template will be compiled if the inline template or file has not been compiled yet,
-      # if local_assigns has a new key, which isn't supported by the compiled code yet,
-      # or if the file has changed on disk and checking file mods hasn't been disabled.
-      def compile_template?(template, file_name, local_assigns)
-        method_key    = file_name || template
-        render_symbol = @@method_names[method_key]
-
-        compile_time = @@compile_time[render_symbol]
-        if compile_time && supports_local_assigns?(render_symbol, local_assigns)
-          if file_name && !@@cache_template_loading
-            template_changed_since?(file_name, compile_time)
-          end
-        else
-          true
-        end
-      end
-
-      # Method to handle checking a whether a template has changed since last compile; isolated so that templates
-      # not stored on the file system can hook and extend appropriately.
-      def template_changed_since?(file_name, compile_time)
-        lstat = File.lstat(file_name)
-        compile_time < lstat.mtime || 
-          (lstat.symlink? && compile_time < File.stat(file_name).mtime)
-      end
-
-      # Method to create the source code for a given template.
-      def create_template_source(handler, template, render_symbol, locals)
-        body = delegate_compile(handler, template)
-
-        @@template_args[render_symbol] ||= {}
-        locals_keys = @@template_args[render_symbol].keys | locals
-        @@template_args[render_symbol] = locals_keys.inject({}) { |h, k| h[k] = true; h }
-
-        locals_code = ""
-        locals_keys.each do |key|
-          locals_code << "#{key} = local_assigns[:#{key}]\n"
-        end
-
-        "def #{render_symbol}(local_assigns)\n#{locals_code}#{body}\nend"
-      end
-
-      def assign_method_name(handler, template, file_name)
-        method_key = file_name || template
-        @@method_names[method_key] ||= compiled_method_name(handler, template, file_name)
-      end
-
-      def compiled_method_name(handler, template, file_name)
-        ['_run', handler.to_s.demodulize.underscore, compiled_method_name_file_path_segment(file_name)].compact.join('_').to_sym
-      end
-
-      def compiled_method_name_file_path_segment(file_name)
-        if file_name
-          s = File.expand_path(file_name)
-          s.sub!(/^#{Regexp.escape(File.expand_path(RAILS_ROOT))}/, '') if defined?(RAILS_ROOT)
-          s.gsub!(/([^a-zA-Z0-9_])/) { $1.ord }
-          s
-        else
-          (@@inline_template_count += 1).to_s
-        end
-      end
-
-      # Compile and evaluate the template's code
-      def compile_template(handler, template, file_name, local_assigns)
-        render_symbol = assign_method_name(handler, template, file_name)
-        render_source = create_template_source(handler, template, render_symbol, local_assigns.keys)
-        line_offset   = @@template_args[render_symbol].size + handler.line_offset
-
-        begin
-          file_name = 'compiled-template' if file_name.blank?
-          CompiledTemplates.module_eval(render_source, file_name, -line_offset)
-        rescue Exception => e  # errors from template code
-          if logger
-            logger.debug "ERROR: compiling #{render_symbol} RAISED #{e}"
-            logger.debug "Function body: #{render_source}"
-            logger.debug "Backtrace: #{e.backtrace.join("\n")}"
-          end
-
-          raise TemplateError.new(extract_base_path_from(file_name) || view_paths.first, file_name || template, @assigns, template, e)
-        end
-
-        @@compile_time[render_symbol] = Time.now
-        # logger.debug "Compiled template #{file_name || template}\n  ==> #{render_symbol}" if logger
-      end
-
-      # Render the provided template with the given local assigns. If the template has not been rendered with the provided
-      # local assigns yet, or if the template has been updated on disk, then the template will be compiled to a method.
-      #
-      # Either, but not both, of template and file_path may be nil. If file_path is given, the template
-      # will only be read if it has to be compiled.
-      #
-      def compile_and_render_template(handler, template = nil, file_path = nil, local_assigns = {}) #:nodoc:
-        # convert string keys to symbols if requested
-        local_assigns = local_assigns.symbolize_keys if @@local_assigns_support_string_keys
-
-        # compile the given template, if necessary
-        if compile_template?(template, file_path, local_assigns)
-          template ||= read_template_file(file_path, nil)
-          compile_template(handler, template, file_path, local_assigns)
-        end
-
-        # Get the method name for this template and run it
-        method_name = @@method_names[file_path || template]
-        evaluate_assigns
-
-        send(method_name, local_assigns) do |*name|
-          instance_variable_get "@content_for_#{name.first || 'layout'}"
-        end
+      
+      def execute(template)
+        send(template.method, template.locals) do |*names|
+          instance_variable_get "@content_for_#{names.first || 'layout'}"
+        end        
       end
   end
 end