* Pass around handler instances, not their classes [Koz]

* Move compilation, rendering and 'compilable?' checks into the Handlers [Koz]
 * Remove delegate_* methods as the handler is now an instance [Koz]


git-svn-id: http://svn-commit.rubyonrails.org/rails/trunk@8624 5ecf4fe2-1ee6-0310-87b1-e25e094e27de

actionpack/lib/action_view/base.rb

@@ -252,7 +252,7 @@ module ActionView #:nodoc:
       @@default_template_handlers = klass
     end
 
-    def self.handler_for_extension(extension)
+    def self.handler_class_for_extension(extension)
       (extension && @@template_handlers[extension.to_sym]) || @@default_template_handlers
     end
 
@@ -361,13 +361,13 @@ If you are rendering a subtemplate, you must now use controller-like partial syn
     # 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)
+      handler = self.class.handler_class_for_extension(template_extension).new(self)
 
-      if template_handler_is_compilable?(handler)
+      if handler.compilable?
         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)
+        handler.render(template, local_assigns)
       end
     end
 
@@ -513,18 +513,6 @@ 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) }
@@ -565,7 +553,7 @@ If you are rendering a subtemplate, you must now use controller-like partial syn
 
       # Method to create the source code for a given template.
       def create_template_source(handler, template, render_symbol, locals)
-        body = delegate_compile(handler, template)
+        body = handler.compile(template)
 
         @@template_args[render_symbol] ||= {}
         locals_keys = @@template_args[render_symbol].keys | locals
@@ -585,7 +573,7 @@ If you are rendering a subtemplate, you must now use controller-like partial syn
       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
+        ['_run', handler.class.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)

actionpack/lib/action_view/template_handler.rb

@@ -4,6 +4,10 @@ module ActionView
       0
     end
 
+    def self.compilable?
+      false
+    end
+
     def initialize(view)
       @view = view
     end
@@ -14,6 +18,14 @@ module ActionView
     def compile(template)
     end
 
+    def compilable?
+      self.class.compilable?
+    end
+
+    def line_offset
+      self.class.line_offset
+    end
+
     # Called by CacheHelper#cache
     def cache_fragment(block, name = {}, options = nil)
     end

actionpack/lib/action_view/template_handlers/builder.rb

@@ -7,6 +7,10 @@ module ActionView
         2
       end
 
+      def self.compilable?
+        true
+      end
+
       def compile(template)
         content_type_handler = (@view.send!(:controller).respond_to?(:response) ? "controller.response" : "controller")
         "#{content_type_handler}.content_type ||= Mime::XML\n" +

actionpack/lib/action_view/template_handlers/erb.rb

@@ -26,6 +26,10 @@ module ActionView
         ::ERB.new(template, nil, @view.erb_trim_mode).src
       end
 
+      def self.compilable?
+        true
+      end
+
       def cache_fragment(block, name = {}, options = nil) #:nodoc:
         @view.fragment_for(block, name, options) do
           eval(ActionView::Base.erb_variable, block.binding)

actionpack/lib/action_view/template_handlers/rjs.rb

@@ -10,6 +10,10 @@ module ActionView
         "update_page do |page|\n#{template}\nend"
       end
 
+      def self.compilable?
+        true
+      end
+
       def cache_fragment(block, name = {}, options = nil) #:nodoc:
         @view.fragment_for(block, name, options) do
           begin

actionpack/test/controller/custom_handler_test.rb

@@ -1,6 +1,6 @@
 require 'abstract_unit'
 
-class CustomHandler
+class CustomHandler < ActionView::TemplateHandler
   def initialize( view )
     @view = view
   end

actionpack/test/controller/layout_test.rb

@@ -31,7 +31,7 @@ end
 class MultipleExtensions < LayoutTest
 end
 
-class MabView
+class MabView < ActionView::TemplateHandler
   def initialize(view)
   end
   
@@ -67,6 +67,7 @@ class LayoutAutoDiscoveryTest < Test::Unit::TestCase
     get :hello
     assert_equal 'layouts/third_party_template_library', @controller.active_layout
     assert_equal 'layouts/third_party_template_library', @response.layout
+    assert_response :success
     assert_equal 'Mab', @response.body
   end
   

actionpack/test/template/compiled_templates_test.rb

@@ -73,115 +73,116 @@ class CompiledTemplateTests < Test::Unit::TestCase
   end
 
   uses_mocha 'test_compile_time' do
-  def test_compile_time
-    t = Time.now
 
-    File.open(@a, "w"){|f| f.puts @a}
-    File.open(@b, "w"){|f| f.puts @b}
-    # windows doesn't support symlinks (even under cygwin)
-    windows = (RUBY_PLATFORM =~ /win32/)
-    `ln -s #{@a} #{@s}` unless windows
+    def test_compile_time
+      t = Time.now
 
-    v = ActionView::Base.new
-    v.base_path = '.'
-    v.cache_template_loading = false
+      File.open(@a, "w"){|f| f.puts @a}
+      File.open(@b, "w"){|f| f.puts @b}
+      # windows doesn't support symlinks (even under cygwin)
+      windows = (RUBY_PLATFORM =~ /win32/)
+      `ln -s #{@a} #{@s}` unless windows
 
-    # All templates were created at t+1
-    File::Stat.any_instance.expects(:mtime).times(windows ? 2 : 3).returns(t + 1.second)
+      v = ActionView::Base.new
+      v.base_path = '.'
+      v.cache_template_loading = false
 
-    # private methods template_changed_since? and compile_template?
-    # should report true for all since they have not been compiled
-    assert v.send(:template_changed_since?, @a, t)
-    assert v.send(:template_changed_since?, @b, t)
-    assert v.send(:template_changed_since?, @s, t) unless windows
+      # All templates were created at t+1
+      File::Stat.any_instance.expects(:mtime).times(windows ? 2 : 3).returns(t + 1.second)
 
-    assert v.send(:compile_template?, nil, @a, {})
-    assert v.send(:compile_template?, nil, @b, {})
-    assert v.send(:compile_template?, nil, @s, {}) unless windows
+      # private methods template_changed_since? and compile_template?
+      # should report true for all since they have not been compiled
+      assert v.send(:template_changed_since?, @a, t)
+      assert v.send(:template_changed_since?, @b, t)
+      assert v.send(:template_changed_since?, @s, t) unless windows
 
-    @handler = ActionView::Base.handler_for_extension(:rhtml)
+      assert v.send(:compile_template?, nil, @a, {})
+      assert v.send(:compile_template?, nil, @b, {})
+      assert v.send(:compile_template?, nil, @s, {}) unless windows
 
-    # All templates are rendered at t+2
-    Time.expects(:now).times(windows ? 2 : 3).returns(t + 2.seconds)
-    v.send(:compile_and_render_template, @handler, '', @a)
-    v.send(:compile_and_render_template, @handler, '', @b)
-    v.send(:compile_and_render_template, @handler, '', @s) unless windows
-    a_n = v.method_names[@a]
-    b_n = v.method_names[@b]
-    s_n = v.method_names[@s] unless windows
-    # all of the files have changed since last compile
-    assert v.compile_time[a_n] > t
-    assert v.compile_time[b_n] > t
-    assert v.compile_time[s_n] > t unless windows
+      @handler_class = ActionView::Base.handler_class_for_extension(:rhtml)
+      @handler       = @handler_class.new(v)
+      # All templates are rendered at t+2
+      Time.expects(:now).times(windows ? 2 : 3).returns(t + 2.seconds)
+      v.send(:compile_and_render_template, @handler, '', @a)
+      v.send(:compile_and_render_template, @handler, '', @b)
+      v.send(:compile_and_render_template, @handler, '', @s) unless windows
+      a_n = v.method_names[@a]
+      b_n = v.method_names[@b]
+      s_n = v.method_names[@s] unless windows
+      # all of the files have changed since last compile
+      assert v.compile_time[a_n] > t
+      assert v.compile_time[b_n] > t
+      assert v.compile_time[s_n] > t unless windows
 
-    # private methods template_changed_since? and compile_template?
-    # should report false for all since none have changed since compile
-    File::Stat.any_instance.expects(:mtime).times(windows ? 6 : 12).returns(t + 1.second)
-    assert !v.send(:template_changed_since?, @a, v.compile_time[a_n])
-    assert !v.send(:template_changed_since?, @b, v.compile_time[b_n])
-    assert !v.send(:template_changed_since?, @s, v.compile_time[s_n]) unless windows
-    assert !v.send(:compile_template?, nil, @a, {})
-    assert !v.send(:compile_template?, nil, @b, {})
-    assert !v.send(:compile_template?, nil, @s, {}) unless windows
-    v.send(:compile_and_render_template, @handler, '', @a)
-    v.send(:compile_and_render_template, @handler, '', @b)
-    v.send(:compile_and_render_template, @handler, '', @s)  unless windows
-    # none of the files have changed since last compile
-    assert v.compile_time[a_n] < t + 3.seconds
-    assert v.compile_time[b_n] < t + 3.seconds
-    assert v.compile_time[s_n] < t + 3.seconds  unless windows
+      # private methods template_changed_since? and compile_template?
+      # should report false for all since none have changed since compile
+      File::Stat.any_instance.expects(:mtime).times(windows ? 6 : 12).returns(t + 1.second)
+      assert !v.send(:template_changed_since?, @a, v.compile_time[a_n])
+      assert !v.send(:template_changed_since?, @b, v.compile_time[b_n])
+      assert !v.send(:template_changed_since?, @s, v.compile_time[s_n]) unless windows
+      assert !v.send(:compile_template?, nil, @a, {})
+      assert !v.send(:compile_template?, nil, @b, {})
+      assert !v.send(:compile_template?, nil, @s, {}) unless windows
+      v.send(:compile_and_render_template, @handler, '', @a)
+      v.send(:compile_and_render_template, @handler, '', @b)
+      v.send(:compile_and_render_template, @handler, '', @s)  unless windows
+      # none of the files have changed since last compile
+      assert v.compile_time[a_n] < t + 3.seconds
+      assert v.compile_time[b_n] < t + 3.seconds
+      assert v.compile_time[s_n] < t + 3.seconds  unless windows
 
-    `rm #{@s}; ln -s #{@b} #{@s}` unless windows
-    # private methods template_changed_since? and compile_template?
-    # should report true for symlink since it has changed since compile
+      `rm #{@s}; ln -s #{@b} #{@s}` unless windows
+      # private methods template_changed_since? and compile_template?
+      # should report true for symlink since it has changed since compile
     
-    # t + 3.seconds is for the symlink
-    File::Stat.any_instance.expects(:mtime).times(windows ? 6 : 9).returns(
-      *(windows ? [ t + 1.second, t + 1.second ] :
-        [ t + 1.second, t + 1.second, t + 3.second ]) * 3)
-    assert !v.send(:template_changed_since?, @a, v.compile_time[a_n])
-    assert !v.send(:template_changed_since?, @b, v.compile_time[b_n])
-    assert v.send(:template_changed_since?, @s, v.compile_time[s_n]) unless windows
-    assert !v.send(:compile_template?, nil, @a, {})
-    assert !v.send(:compile_template?, nil, @b, {})
-    assert v.send(:compile_template?, nil, @s, {}) unless windows
+      # t + 3.seconds is for the symlink
+      File::Stat.any_instance.expects(:mtime).times(windows ? 6 : 9).returns(
+        *(windows ? [ t + 1.second, t + 1.second ] :
+          [ t + 1.second, t + 1.second, t + 3.second ]) * 3)
+      assert !v.send(:template_changed_since?, @a, v.compile_time[a_n])
+      assert !v.send(:template_changed_since?, @b, v.compile_time[b_n])
+      assert v.send(:template_changed_since?, @s, v.compile_time[s_n]) unless windows
+      assert !v.send(:compile_template?, nil, @a, {})
+      assert !v.send(:compile_template?, nil, @b, {})
+      assert v.send(:compile_template?, nil, @s, {}) unless windows
 
-    # Only the symlink template gets rendered at t+3
-    Time.stubs(:now).returns(t + 3.seconds) unless windows
-    v.send(:compile_and_render_template, @handler, '', @a)
-    v.send(:compile_and_render_template, @handler, '', @b)
-    v.send(:compile_and_render_template, @handler, '', @s) unless windows
-    # the symlink has changed since last compile
-    assert v.compile_time[a_n] < t + 3.seconds
-    assert v.compile_time[b_n] < t + 3.seconds
-    assert_equal v.compile_time[s_n], t + 3.seconds unless windows
+      # Only the symlink template gets rendered at t+3
+      Time.stubs(:now).returns(t + 3.seconds) unless windows
+      v.send(:compile_and_render_template, @handler, '', @a)
+      v.send(:compile_and_render_template, @handler, '', @b)
+      v.send(:compile_and_render_template, @handler, '', @s) unless windows
+      # the symlink has changed since last compile
+      assert v.compile_time[a_n] < t + 3.seconds
+      assert v.compile_time[b_n] < t + 3.seconds
+      assert_equal v.compile_time[s_n], t + 3.seconds unless windows
 
-    FileUtils.touch @b
-    # private methods template_changed_since? and compile_template?
-    # should report true for symlink and file at end of symlink
-    # since it has changed since last compile
-    #
-    # t+4 is for @b and also for the file that @s points to, which is @b
-    File::Stat.any_instance.expects(:mtime).times(windows ? 6 : 12).returns(
-      *(windows ? [ t + 1.second, t + 4.seconds ] :
-        [ t + 1.second, t + 4.seconds, t + 3.second, t + 4.seconds ]) * 3)
-    assert !v.send(:template_changed_since?, @a, v.compile_time[a_n])
-    assert v.send(:template_changed_since?, @b, v.compile_time[b_n])
-    assert v.send(:template_changed_since?, @s, v.compile_time[s_n]) unless windows
-    assert !v.send(:compile_template?, nil, @a, {})
-    assert v.send(:compile_template?, nil, @b, {})
-    assert v.send(:compile_template?, nil, @s, {}) unless windows
+      FileUtils.touch @b
+      # private methods template_changed_since? and compile_template?
+      # should report true for symlink and file at end of symlink
+      # since it has changed since last compile
+      #
+      # t+4 is for @b and also for the file that @s points to, which is @b
+      File::Stat.any_instance.expects(:mtime).times(windows ? 6 : 12).returns(
+        *(windows ? [ t + 1.second, t + 4.seconds ] :
+          [ t + 1.second, t + 4.seconds, t + 3.second, t + 4.seconds ]) * 3)
+      assert !v.send(:template_changed_since?, @a, v.compile_time[a_n])
+      assert v.send(:template_changed_since?, @b, v.compile_time[b_n])
+      assert v.send(:template_changed_since?, @s, v.compile_time[s_n]) unless windows
+      assert !v.send(:compile_template?, nil, @a, {})
+      assert v.send(:compile_template?, nil, @b, {})
+      assert v.send(:compile_template?, nil, @s, {}) unless windows
 
-    Time.expects(:now).times(windows ? 1 : 2).returns(t + 5.seconds)
-    v.send(:compile_and_render_template, @handler, '', @a)
-    v.send(:compile_and_render_template, @handler, '', @b)
-    v.send(:compile_and_render_template, @handler, '', @s) unless windows
-    # the file at the end of the symlink has changed since last compile
-    # both the symlink and the file at the end of it should be recompiled
-    assert v.compile_time[a_n] < t + 5.seconds
-    assert_equal v.compile_time[b_n], t + 5.seconds
-    assert_equal v.compile_time[s_n], t + 5.seconds unless windows
-  end
+      Time.expects(:now).times(windows ? 1 : 2).returns(t + 5.seconds)
+      v.send(:compile_and_render_template, @handler, '', @a)
+      v.send(:compile_and_render_template, @handler, '', @b)
+      v.send(:compile_and_render_template, @handler, '', @s) unless windows
+      # the file at the end of the symlink has changed since last compile
+      # both the symlink and the file at the end of it should be recompiled
+      assert v.compile_time[a_n] < t + 5.seconds
+      assert_equal v.compile_time[b_n], t + 5.seconds
+      assert_equal v.compile_time[s_n], t + 5.seconds unless windows
+    end
   end
 end