radiant 0.6.9 → 0.7.0

data/vendor/rails/actionpack/lib/action_controller/url_rewriter.rb

@@ -1,82 +1,89 @@
-module ActionController  
+module ActionController
   # Write URLs from arbitrary places in your codebase, such as your mailers.
-  # 
+  #
   # Example:
-  # 
+  #
   #   class MyMailer
   #     include ActionController::UrlWriter
   #     default_url_options[:host] = 'www.basecamphq.com'
-  #     
+  #
   #     def signup_url(token)
   #       url_for(:controller => 'signup', action => 'index', :token => token)
   #     end
   #  end
-  # 
+  #
   # 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 = {}
-    
+
     def self.included(base) #:nodoc:
-      ActionController::Routing::Routes.install_helpers base 
+      ActionController::Routing::Routes.install_helpers(base)
       base.mattr_accessor :default_url_options
       base.default_url_options ||= default_url_options
     end
-    
-    # Generate a url based on the options provided, default_url_options and the 
+
+    # 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.
-    # 
-    # Any other key(:controller, :action, etc...) given to <tt>url_for</tt> is forwarded to the Routes module.
-    # 
+    #
+    # * <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 (<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)
-      
+
       url = ''
 
-      unless options.delete :only_path
+      unless options.delete(:only_path)
         url << (options.delete(:protocol) || 'http')
-        url << '://' unless url.match("://") #dont add separator if its already been specified in :protocol 
-        
+        url << '://' unless url.match("://")
+
         raise "Missing host to link to! Please provide :host parameter or set default_url_options[:host]" unless options[:host]
 
         url << options.delete(:host)
         url << ":#{options.delete(:port)}" if options.key?(:port)
       else
-        # Delete the unused options to prevent their appearance in the query string
-        [:protocol, :host, :port].each { |k| options.delete k }
+        # 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
-
-      anchor = "##{CGI.escape options.delete(:anchor).to_param.to_s}" if options.key?(:anchor)
-      url << Routing::Routes.generate(options, {})
+      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]
+      generated = Routing::Routes.generate(options, {})
+      url << (trailing_slash ? generated.sub(/\?|\z/) { "/" + $& } : generated)
       url << anchor if anchor
 
-      return url
-    end    
+      url
+    end
   end
-  
+
   # Rewrites URLs for Base.redirect_to and Base.url_for in the controller.
   class UrlRewriter #:nodoc:
     RESERVED_OPTIONS = [:anchor, :params, :only_path, :host, :protocol, :port, :trailing_slash, :skip_relative_url_root]
     def initialize(request, parameters)
       @request, @parameters = request, parameters
     end
-    
+
     def rewrite(options = {})
       rewrite_url(options)
     end
@@ -123,7 +130,7 @@ module ActionController
         # Generates the query string, too
         Routing::Routes.generate(options, @request.symbolized_path_parameters)
       end
-      
+
       def rewrite_authentication(options)
         if options[:user] && options[:password]
           "#{CGI.escape(options.delete(:user))}:#{CGI.escape(options.delete(:password))}@"

data/vendor/rails/actionpack/lib/action_controller/vendor/html-scanner/html/document.rb

@@ -17,7 +17,7 @@ module HTML #:nodoc:
       @root = Node.new(nil)
       node_stack = [ @root ]
       while token = tokenizer.next
-        node = Node.parse(node_stack.last, tokenizer.line, tokenizer.position, token)
+        node = Node.parse(node_stack.last, tokenizer.line, tokenizer.position, token, strict)
 
         node_stack.last.children << node unless node.tag? && node.closing == :close
         if node.tag?

data/vendor/rails/actionpack/lib/action_controller/vendor/html-scanner/html/sanitizer.rb

@@ -107,7 +107,7 @@ module HTML
 
       # gauntlet
       if style !~ /^([:,;#%.\sa-zA-Z0-9!]|\w-\w|\'[\s\w]+\'|\"[\s\w]+\"|\([\d,\s]+\))*$/ ||
-          style !~ /^(\s*[-\w]+\s*:\s*[^:;]*(;|$))*$/
+          style !~ /^(\s*[-\w]+\s*:\s*[^:;]*(;|$)\s*)*$/
         return ''
       end
 
@@ -170,4 +170,4 @@ module HTML
       (value =~ /(^[^\/:]*):|(&#0*58)|(&#x70)|(%|%)3A/ && !allowed_protocols.include?(value.split(protocol_separator).first))
     end
   end
-end
+end

data/vendor/rails/actionpack/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/vendor/rails/actionpack/lib/action_controller/verification.rb

@@ -43,72 +43,88 @@ module ActionController #:nodoc:
       # the user is redirected to a different action. The +options+ parameter
       # is a hash consisting of the following key/value pairs:
       #
-      # * <tt>:params</tt> - a single key or an array of keys that must
-      #   be in the <tt>params</tt> hash in order for the action(s) to be safely
-      #   called.
-      # * <tt>:session</tt> - a single key or an array of keys that must
-      #   be in the <tt>session</tt> in order for the action(s) to be safely called.
-      # * <tt>:flash</tt> - a single key or an array of keys that must
-      #   be in the flash in order for the action(s) to be safely called.
-      # * <tt>:method</tt> - a single key or an array of keys--any one of which
-      #   must match the current request method in order for the action(s) to
-      #   be safely called. (The key should be a symbol: <tt>:get</tt> or
-      #   <tt>:post</tt>, for example.)
-      # * <tt>:xhr</tt> - true/false option to ensure that the request is coming
-      #   from an Ajax call or not. 
-      # * <tt>:add_flash</tt> - a hash of name/value pairs that should be merged
-      #   into the session's flash if the prerequisites cannot be satisfied.
-      # * <tt>:add_headers</tt> - a hash of name/value pairs that should be
-      #   merged into the response's headers hash if the prerequisites cannot
-      #   be satisfied.
-      # * <tt>:redirect_to</tt> - the redirection parameters to be used when
-      #   redirecting if the prerequisites cannot be satisfied. You can 
-      #   redirect either to named route or to the action in some controller.
-      # * <tt>:render</tt> - the render parameters to be used when
-      #   the prerequisites cannot be satisfied.
-      # * <tt>:only</tt> - only apply this verification to the actions specified
-      #   in the associated array (may also be a single value).
-      # * <tt>:except</tt> - do not apply this verification to the actions
-      #   specified in the associated array (may also be a single value).
+      # <tt>:params</tt>:: 
+      #   a single key or an array of keys that must be in the <tt>params</tt> 
+      #   hash in order for the action(s) to be safely called.
+      # <tt>:session</tt>:: 
+      #   a single key or an array of keys that must be in the <tt>session</tt> 
+      #   in order for the action(s) to be safely called.
+      # <tt>:flash</tt>:: 
+      #   a single key or an array of keys that must be in the flash in order 
+      #   for the action(s) to be safely called.
+      # <tt>:method</tt>:: 
+      #   a single key or an array of keys--any one of which must match the 
+      #   current request method in order for the action(s) to be safely called. 
+      #   (The key should be a symbol: <tt>:get</tt> or <tt>:post</tt>, for 
+      #   example.)
+      # <tt>:xhr</tt>:: 
+      #   true/false option to ensure that the request is coming from an Ajax 
+      #   call or not. 
+      # <tt>:add_flash</tt>:: 
+      #   a hash of name/value pairs that should be merged into the session's 
+      #   flash if the prerequisites cannot be satisfied.
+      # <tt>:add_headers</tt>:: 
+      #   a hash of name/value pairs that should be merged into the response's 
+      #   headers hash if the prerequisites cannot be satisfied.
+      # <tt>:redirect_to</tt>:: 
+      #   the redirection parameters to be used when redirecting if the 
+      #   prerequisites cannot be satisfied. You can redirect either to named 
+      #   route or to the action in some controller.
+      # <tt>:render</tt>:: 
+      #   the render parameters to be used when the prerequisites cannot be satisfied.
+      # <tt>:only</tt>:: 
+      #   only apply this verification to the actions specified in the associated 
+      #   array (may also be a single value).
+      # <tt>:except</tt>:: 
+      #   do not apply this verification to the actions specified in the associated 
+      #   array (may also be a single value).
       def verify(options={})
-        filter_opts = { :only => options[:only], :except => options[:except] }
-        before_filter(filter_opts) do |c|
+        before_filter :only => options[:only], :except => options[:except] do |c|
           c.send! :verify_action, options
         end
       end
     end
 
+  private
+
     def verify_action(options) #:nodoc:
-      prereqs_invalid =
-        [*options[:params] ].find { |v| params[v].nil?  } ||
-        [*options[:session]].find { |v| session[v].nil? } ||
-        [*options[:flash]  ].find { |v| flash[v].nil?   }
-      
-      if !prereqs_invalid && options[:method]
-        prereqs_invalid ||= 
-          [*options[:method]].all? { |v| request.method != v.to_sym }
-      end
-      
-      prereqs_invalid ||= (request.xhr? != options[:xhr]) unless options[:xhr].nil?
-      
-      if prereqs_invalid
-        flash.update(options[:add_flash]) if options[:add_flash]
+      if prereqs_invalid?(options)
+        flash.update(options[:add_flash])              if options[:add_flash]
         response.headers.update(options[:add_headers]) if options[:add_headers]
-
-        unless performed?
-          case
-          when options[:render]
-            render(options[:render])
-          when options[:redirect_to]
-            options[:redirect_to] = self.send!(options[:redirect_to]) if options[:redirect_to].is_a?(Symbol)
-            redirect_to(options[:redirect_to])
-          else
-            head(:bad_request)
-          end
-        end
+        apply_remaining_actions(options)               unless performed?
+      end
+    end
+    
+    def prereqs_invalid?(options) # :nodoc:
+      verify_presence_of_keys_in_hash_flash_or_params(options) || 
+      verify_method(options) || 
+      verify_request_xhr_status(options)
+    end
+ 
+    def verify_presence_of_keys_in_hash_flash_or_params(options) # :nodoc:
+      [*options[:params] ].find { |v| params[v].nil?  } ||
+      [*options[:session]].find { |v| session[v].nil? } ||
+      [*options[:flash]  ].find { |v| flash[v].nil?   }
+    end
+    
+    def verify_method(options) # :nodoc:
+      [*options[:method]].all? { |v| request.method != v.to_sym } if options[:method]
+    end
+    
+    def verify_request_xhr_status(options) # :nodoc:
+      request.xhr? != options[:xhr] unless options[:xhr].nil?
+    end
+    
+    def apply_redirect_to(redirect_to_option) # :nodoc:
+      (redirect_to_option.is_a?(Symbol) && redirect_to_option != :back) ? self.send!(redirect_to_option) : redirect_to_option
+    end
+    
+    def apply_remaining_actions(options) # :nodoc:
+      case
+        when options[:render]      ; render(options[:render])
+        when options[:redirect_to] ; redirect_to(apply_redirect_to(options[:redirect_to]))
+        else head(:bad_request)
       end
     end
-
-    private :verify_action
   end
 end

data/vendor/rails/actionpack/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/vendor/rails/actionpack/lib/action_pack/version.rb

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

data/vendor/rails/actionpack/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/vendor/rails/actionpack/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,14 +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
+    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.
@@ -167,109 +168,64 @@ 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
     cattr_accessor :debug_rjs
-    
+
     @@erb_variable = '_erbout'
     cattr_accessor :erb_variable
-    
-    delegate :request_forgery_protection_token, :to => :controller
+    class << self
+      deprecate :erb_variable= => 'The erb variable will no longer be configurable. Use the concat helper method instead of appending to it directly.'
+    end
+
+    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, 
@@ -289,123 +245,45 @@ 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)
+        use_full_path = options[:use_full_path]
         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?
-            @content_for_layout = capture(&block)
-            concat(render(options.merge(:partial => "#{path}/#{partial_name}")), block.binding)
+            wrap_content_for_layout capture(&block) do 
+              concat(render(options.merge(:partial => partial_layout)), block.binding)
+            end
           else
-            @content_for_layout = render(options)
-            render(options.merge(:partial => "#{path}/#{partial_name}"))
+            wrap_content_for_layout render(options) do
+              render(options.merge(:partial => partial_layout))
+            end
           end
         elsif options[:file]
-          render_file(options[:file], options[:use_full_path], options[:locals])
+          render_file(options[:file], use_full_path || false, options[:locals])
         elsif options[:partial] && options[:collection]
           render_partial_collection(options[:partial], options[:collection], options[:spacer_template], options[:locals])
         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.
@@ -413,88 +291,38 @@ 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)
-    end
+      if controller && controller.respond_to?(:request)
+        parameter_format = controller.request.parameters[:format]
+        accept_format    = controller.request.accepts.first
 
-    private
-      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
+        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
-        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]
+      else
+        @template_format = :html
       end
+    end
 
-      # This method reads a template file.
-      def read_template_file(template_path, extension)
-        File.read(template_path)
+    private
+      def wrap_content_for_layout(content)
+        original_content_for_layout = @content_for_layout
+        @content_for_layout = content
+        returning(yield) { @content_for_layout = original_content_for_layout }
       end
 
       # Evaluate the local assigns and pushes them to the view.
@@ -505,138 +333,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 { |key, value| instance_variable_set("@#{key}", value) }
       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) })
-      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