render_inheritable 0.5.0

data/MIT-LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2010 Pascal Zumkehr
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,77 @@
+= RENDER INHERITABLE
+
+A Rails 3 plugin that allows one to inherit or override single templates for controller hierarchies. Finally, also views and partials remain DRY!
+
+In the default case, a template is searched in the current controller's view folder. If it is not found there, the template with the same name in the view folder of the superclass controller is used. Have a look at the examples for more clarification.
+
+Install the gem with
+ gem install render_inheritable
+
+In your Rails application's +Gemfile+, add
+ gem 'render_inheritable'
+
+To use inheritable templates in a certain controller hierarchy, add this declaration to the respective base controller:
+ render_inheritable
+
+That's it, no more duplications in your views and partials.
+
+== Example
+
+Suppose we have the following files in our Rails app:
+
+# controllers/crud_controller.rb:
+ class CrudController < ApplicationController
+   # use render inheritable for this controller hierarchy
+   render_inheritable
+
+   def index
+     # set @entries in subclasses
+   end
+   ...
+ end
+
+# controllers/messages_controller.rb:
+ class MessagesController < CrudController
+   def index
+     @entries = Message.all
+   end
+   ...
+ end
+
+# views/crud/index.html.erb:
+ <h1>Listing</h1>
+   
+ <%= render :partial => 'list' %>
+   
+ <%= link_to 'New Entry', :url => {:action => 'new'} %>
+
+# views/crud/_list.html.erb:
+ <ul>
+   <% @entries.each do |entry| %>
+  	 <li><%= render :partial => 'entry', :object => 'entry' %></li>
+   <% end %>
+ </ul>
+
+# views/crud/_entry.html.erb
+ <%= entry.to_s %>
+
+Nothing sophisticated, but it will do to explain our little gem. With the call to _render_inheritable_ in the CrudController, we tell all +render+ calls in this controller, its subclasses and their corresponding views to perform a template lookup. What does this mean? When we call the index action of our MessagesController, no corresponding template is found in <i>views/messages/index.html.erb</i>. The lookup proceeds to the superclass controller, where it finds the template in <i>views/crud/index.html.erb</i>. The same holds for the two partials <i>views/crud/_list.html.erb</i> and <i>views/crud/_entry.html.erb</i>. 
+
+With this mechanism, we are able to define generic templates that are *inherited* to various subclass controllers. There is no need to duplicate templates when they basically look the same.
+
+If we need to customize a certain part, it is possible to *override* a single template or partial. Say we would like to present a custom entry for messages. Just introduce the corresponding partial:
+
+# views/messages/_entry.html.erb
+ <%= entry.title %>: <%= truncate(entry.body, :length => 20) %>
+
+
+Now, the <code>render :partial => 'entry'</code> call in <i>views/crud/_list.html.erb</i> will find the partial in the <i>views/messages</i> folder and render it. The other two templates do not have to be touched and are still inherited form the <i>views/crud</i> folder. So it's possible to customize certain snippets by specifically overriding partials. For this example, you could also create a partial <i>views/messages/_list.html.erb</i> to display a table instead of a list for messages.
+
+Of course, the lookup not only works for HTML templates and partials, but for any format. Even <code>page.replace 'element_id', :partial => 'element'</code> calls in RJS templates benefit from this gem.
+
+
+== Custom Lookup Paths
+
+To support more advanced lookups, it is possible to customize the used lookup path. You may override the method <code>self.template_lookup_path(param = nil)</code> in the controller where you defined +render_inheritable+. This method is expected to return an ordered list of controller_paths where the templates are searched in.
+
+With the optional parameter +param+, definable in the controller instance method +template_lookup_param+, lookup paths may even be dynamic. This would allow you, for example, to perform a template lookup based on a type attribute from your model instance. Each type would get an own _views_ subfolder, where specific views or partials might be overriden. These subfolders then would not need to match an existing controller.

data/Rakefile

@@ -0,0 +1,92 @@
+require 'rubygems'
+require "rake/testtask"
+require 'rake/gempackagetask' 
+require 'rake/rdoctask' 
+sdoc = (require 'sdoc' || true) rescue false
+
+load	'render_inheritable.gemspec'
+
+TEST_APP_ROOT  = File.join(File.dirname(__FILE__), 'test', 'test_app')
+
+task :default => :test
+
+desc "Run all tests"
+task :test => ['test:app:init'] do
+	Rake::TestTask.new do |test| 
+		test.libs << "#{TEST_APP_ROOT}/test" 
+		test.test_files = Dir[ "#{TEST_APP_ROOT}/test/**/*_test.rb" ] 
+		test.verbose = true
+	end
+end
+
+namespace :test do
+	namespace :app do
+		desc "Create a rails test application"
+		task :create do
+			unless File.exist?(TEST_APP_ROOT)
+				sh "rails _3.0.0.beta4_ new #{TEST_APP_ROOT}"
+			end
+		end
+		      
+    desc "Initializes the test application with a couple of classes"
+    task :init => :create do
+      FileUtils.cp_r(File.join(File.dirname(__FILE__), 'test', 'templates', '.'), TEST_APP_ROOT)
+      FileUtils.cd(TEST_APP_ROOT) do
+          sh "rake db:migrate db:test:prepare"
+      end
+    end
+    
+		task :environment => :init do
+		  ::RAILS_ROOT = TEST_APP_ROOT
+		  ::RAILS_ENV = 'test'
+		  
+		  require(File.join(TEST_APP_ROOT, 'config', 'environment'))
+		end
+
+	end
+end
+
+desc "Clean up all generated resources"
+task :clobber do
+	FileUtils.rm_rf(TEST_APP_ROOT)
+end
+
+desc "Install render_inheritable as a local gem." 
+task :install => [:package] do
+	sudo = RUBY_PLATFORM =~ /win32/ ? '' : 'sudo' 
+	gem = RUBY_PLATFORM =~ /java/ ? 'jgem' : 'gem' 
+	sh %{#{sudo} #{gem} install --no-ri pkg/render_inheritable-#{File.read('VERSION').strip}}
+end
+
+desc "Deploy rdoc to website"
+task :site => :rdoc do
+  sh "rsync -rzv rdoc/ #{ENV['DEST']}"
+end
+
+# :package task
+Rake::GemPackageTask.new(RENDER_INHERITABLE_GEMSPEC) do |pkg|
+	if Rake.application.top_level_tasks.include?('release')
+		pkg.need_tar_gz = true 
+		pkg.need_tar_bz2 = true 
+		pkg.need_zip	= true
+	end 
+end
+
+# :rdoc task
+Rake::RDocTask.new do |rdoc| 
+	rdoc.title	= 'Render Inheritable' 
+	rdoc.options << '--line-numbers' << '--inline-source'
+    if sdoc
+	    rdoc.options << '--fmt' << 'shtml'
+	    rdoc.template = 'direct'
+    end
+	rdoc.rdoc_files.include(*FileList.new('*') do |list|
+		list.exclude(/(^|[^.a-z])[a-z]+/)
+		list.exclude('TODO') 
+		end.to_a)
+	rdoc.rdoc_files.include('lib/**/*.rb') 
+	rdoc.rdoc_files.exclude('TODO') 
+		
+	rdoc.rdoc_dir = 'rdoc'
+	rdoc.main = 'README.rdoc' 
+end

data/VERSION

@@ -0,0 +1 @@
+0.5.0

data/lib/rails_integration.rb

@@ -0,0 +1,11 @@
+module AbstractController
+  # Add a simple render_inheritable method to AbstractController
+  # to define that rendering should perform a lookup.
+  class Base
+      # Tell the controller, its subclasses and views to use inheritable rendering.
+      def self.render_inheritable
+        include RenderInheritable
+      end
+  end
+  
+end

data/lib/render_inheritable.rb

@@ -0,0 +1,153 @@
+require File.join(File.dirname(__FILE__), 'rails_integration')
+
+# Allows one to render inheritable views and partials.
+# If no view file is found for the current controller, the corresponding file
+# is looked up in its superclass hierarchy. This module must only be
+# included in the root controller of the desired lookup hierarchy.
+# 
+# By default, this module only supports direct inheritance over one level. By overriding
+# the method lookup_path, you may define a custom lookup path. By providing an object
+# for the 'with' parameter, this path may even be dynamic.
+module RenderInheritable
+  
+  # Add inheritable_root_path method to including controller.
+  def self.included(controller_class)
+    controller_class.send(:extend, ClassMethods)
+    
+    controller_class.send(:class_variable_set, :@@inheritable_root_controller, controller_class)
+    controller_class.cattr_reader :inheritable_root_controller
+  end    
+  
+  # Performs a lookup for the given filename and returns the most specific
+  # folder that contains the file.
+  def find_inheritable_template_folder(name, partial = false)
+    self.class.find_inheritable_template_folder(view_context, name, partial, formats, template_lookup_param)
+  end
+  
+  # Override this method to specify a dynamic parameter used in the lookup path.
+  # For the default inheritance lookup, this parameter is not needed.
+  def template_lookup_param
+    nil
+  end
+  
+  module ClassMethods
+    # Performs a lookup for the given filename and returns the most specific
+    # folder that contains the file.
+    def find_inheritable_template_folder(view_context, name, partial, formats, param = nil)  
+      find_inheritable_template_folder_cached(view_context, name, partial, formats, param) do
+        find_inheritable_artifact(param) do |folder|
+          view_context.template_exists?(name, folder, partial)
+        end
+      end
+    end
+    
+    # Performs a lookup for a controller and returns the name of the most specific one found.
+    # This method is primarly usefull when given a 'param' argument that is used
+    # in a custom #template_lookup_path. In this case, no controller class would need to 
+    # exist to render templates from corresponding view folders.
+    def inheritable_controller(param = nil)
+      c = find_inheritable_artifact(param) do |folder|
+        ActionController::Base.subclasses.any? { |c| c.constantize.controller_path == folder }
+      end
+      c || inheritable_root_controller.controller_path
+    end
+    
+    # Runs through the lookup path and yields each folder to the passed block.
+    # If the block returns true, this folder is returned and no further lookup
+    # happens. If no folder is found, the nil is returned.
+    def find_inheritable_artifact(param = nil)
+      template_lookup_path(param).each { |folder| return folder if yield(folder) }
+      nil
+    end
+    
+    # An array of controller names / folders, ordered from most specific to most general.
+    # May be dynamic dependening on the passed 'param' argument. 
+    # You may override this method in an own controller to customize the lookup path.
+    def template_lookup_path(param = nil)
+      inheritance_lookup_path
+    end
+    
+    # The inheritance path of controllers that is used as default lookup path.
+    def inheritance_lookup_path
+      path = [self]
+      until path.last == inheritable_root_controller
+        path << path.last.superclass
+      end
+      path.collect(&:controller_path)
+    end
+    
+    # Override view context class to includes the render inheritable modules.
+    def view_context_class
+      @view_context_class ||= begin
+        Class.new(super) do
+          include RenderInheritable::View
+        end
+      end
+    end
+    
+    private
+    
+    # Performs a lookup for a template folder using the cache.
+    def find_inheritable_template_folder_cached(view_context, name, partial, formats, param = nil)
+      prefix = inheritable_cache_get(formats, name, partial, param)
+      return prefix if prefix
+      
+      prefix = yield
+      
+      if prefix
+        template = view_context.find_template_without_lookup(name, prefix, partial)
+        inheritable_cache_set(template.formats, name, partial, param, prefix)
+      end
+      prefix
+    end
+    
+    # A simple template lookup cache for each controller.
+    def inheritable_cache #:nodoc:
+      # do not store keys on each access, only return default structure
+      @inheritable_cache ||= Hash.new do |h1, k1| 
+        Hash.new do |h2, k2| 
+          Hash.new do |h3, k3| 
+            Hash.new 
+          end
+        end
+      end
+    end
+    
+    # Gets the prefix from the cache. Returns nil if it's not there yet.
+    def inheritable_cache_get(formats, name, partial, param)
+      prefixes = formats.collect { |format| inheritable_cache[format.to_sym][partial][name][param] }
+      prefixes.compact!
+      prefixes.empty? ?  nil : prefixes.first
+    end
+    
+    # Stores the found prefix in the cache.
+    def inheritable_cache_set(formats, name, partial, param, prefix)
+      formats.each do |format|
+        # assign hash default values to respective key 
+        inheritable_cache[format.to_sym] = hf = inheritable_cache[format.to_sym]
+        hf[partial] = hp = hf[partial]
+        hp[name] = hn = hp[name]
+        # finally store prefix in the deepest hash
+        hn[param] = prefix
+      end
+    end
+    
+  end
+  
+  # Extend ActionView so templates are looked up on a find_template call.
+  module View
+    def self.included(base)
+      base.send :alias_method_chain, :find_template, :lookup
+    end
+    
+    # Perform a template lookup if the prefix corresponds to the current controller's path.
+    def find_template_with_lookup(name, prefix = nil, partial = false)
+      if prefix == controller_path
+        folder = controller.find_inheritable_template_folder(name, partial)
+        prefix = folder if folder
+      end
+      find_template_without_lookup(name, prefix, partial)
+    end
+  end
+  
+end

data/test/templates/Gemfile

@@ -0,0 +1,10 @@
+source 'http://rubygems.org'
+
+gem 'rails', '3.0.0.beta4'
+
+# Bundle edge Rails instead:
+# gem 'rails', :git => 'git://github.com/rails/rails.git'
+
+gem 'sqlite3-ruby', :require => 'sqlite3'
+
+gem 'render_inheritable', :path => '../../../render_inheritable'

data/test/templates/app/config/routes.rb

@@ -0,0 +1,58 @@
+TestApp::Application.routes.draw do |map|
+  # The priority is based upon order of creation:
+  # first created -> highest priority.
+
+  # Sample of regular route:
+  #   match 'products/:id' => 'catalog#view'
+  # Keep in mind you can assign values other than :controller and :action
+
+  # Sample of named route:
+  #   match 'products/:id/purchase' => 'catalog#purchase', :as => :purchase
+  # This route can be invoked with purchase_url(:id => product.id)
+
+  # Sample resource route (maps HTTP verbs to controller actions automatically):
+  #   resources :products
+
+  # Sample resource route with options:
+  #   resources :products do
+  #     member do
+  #       get :short
+  #       post :toggle
+  #     end
+  #
+  #     collection do
+  #       get :sold
+  #     end
+  #   end
+
+  # Sample resource route with sub-resources:
+  #   resources :products do
+  #     resources :comments, :sales
+  #     resource :seller
+  #   end
+
+  # Sample resource route with more complex sub-resources
+  #   resources :products do
+  #     resources :comments
+  #     resources :sales do
+  #       get :recent, :on => :collection
+  #     end
+  #   end
+
+  # Sample resource route within a namespace:
+  #   namespace :admin do
+  #     # Directs /admin/products/* to Admin::ProductsController
+  #     # (app/controllers/admin/products_controller.rb)
+  #     resources :products
+  #   end
+
+  # You can have the root of your site routed with "root"
+  # just remember to delete public/index.html.
+  # root :to => "welcome#index"
+
+  # See how all your routes lay out with "rake routes"
+
+  # This is a legacy wild controller route that's not recommended for RESTful applications.
+  # Note: This route will make all actions in every controller accessible via GET requests.
+  match ':controller(/:action(/:id(.:format)))'
+end

data/test/templates/app/controllers/base_controller.rb

@@ -0,0 +1,23 @@
+class BaseController < ApplicationController
+  
+  render_inheritable
+  
+  def inherited
+    respond_to do |format|
+      format.html
+      format.js
+      format.xml
+    end
+  end
+  
+
+  def overriden
+    respond_to do |format|
+      format.html
+      format.js
+      format.xml
+    end
+  end
+  
+  
+end

data/test/templates/app/controllers/child_controller.rb

@@ -0,0 +1,6 @@
+class ChildController < BaseController
+  
+  def overriden
+  end
+
+end

data/test/templates/app/views/base/_inh_partial.html.erb

@@ -0,0 +1 @@
+Inherited Partial Base

data/test/templates/app/views/base/_over_partial.html.erb

@@ -0,0 +1 @@
+Overriden Partial Base

data/test/templates/app/views/base/inherited.html.erb

@@ -0,0 +1,11 @@
+Inherited Base
+
+<%= render :partial => 'inh_partial' %>
+
+<%= render :partial => 'over_partial' %>
+
+
+
+
+
+

data/test/templates/app/views/base/inherited.js.rjs

@@ -0,0 +1,3 @@
+page << "/*  Inherited Base JS */"
+page.replace 'element_id', :partial => 'inh_partial'
+page.replace 'other_id', :partial => 'over_partial'

data/test/templates/app/views/base/overriden.html.erb

@@ -0,0 +1,5 @@
+Overriden Base
+
+<%= render :partial => 'inh_partial' %>
+
+<%= render :partial => 'over_partial' %>

data/test/templates/app/views/base/overriden.js.rjs

@@ -0,0 +1,3 @@
+page << "/* Overriden Base JS */"
+page.replace 'element_id', :partial => 'inh_partial'
+page.replace 'other_id', :partial => 'over_partial'

data/test/templates/app/views/child/_over_partial.html.erb

@@ -0,0 +1 @@
+Overriden Partial Child

data/test/templates/app/views/child/overriden.html.erb

@@ -0,0 +1,5 @@
+Overriden Child
+
+<%= render :partial => 'inh_partial' %>
+
+<%= render :partial => 'over_partial' %>

data/test/templates/app/views/child/overriden.js.rjs

@@ -0,0 +1,3 @@
+page << "/* Overriden Child JS */"
+page.replace 'element_id', :partial => 'inh_partial'
+page.replace 'other_id', :partial => 'over_partial'

data/test/templates/test/functional/base_controller_test.rb

@@ -0,0 +1,33 @@
+require 'test_helper'
+
+class BaseControllerTest < ActionController::TestCase
+  
+  test "base template and partials are rendered for inherited" do
+    get :inherited
+    assert_match /^inherited base$/i, @response.body
+    assert_match /^inherited partial base$/i, @response.body
+    assert_match /^overriden partial base$/i, @response.body
+  end
+    
+  test "base template and partials are rendered for override" do
+    get :overriden
+    assert_match /^overriden base$/i, @response.body
+    assert_match /^inherited partial base$/i, @response.body
+    assert_match /^overriden partial base$/i, @response.body
+  end
+  
+  test "base template and partials are rendered for inherited format js" do
+    get :inherited, :format => :js
+    assert_match /inherited base js/i, @response.body
+    assert_match /inherited partial base/i, @response.body
+    assert_match /overriden partial base/i, @response.body
+  end
+    
+  test "base template and partials are rendered for override format js" do
+    get :overriden, :format => :js
+    assert_match /overriden base js/i, @response.body
+    assert_match /inherited partial base/i, @response.body
+    assert_match /overriden partial base/i, @response.body
+  end
+  
+end

data/test/templates/test/functional/child_controller_test.rb

@@ -0,0 +1,33 @@
+require 'test_helper'
+
+class ChildControllerTest < ActionController::TestCase
+  
+  test "base template and partials are rendered for inherited" do
+    get :inherited
+    assert_match /^inherited base$/i, @response.body
+    assert_match /^inherited partial base$/i, @response.body
+    assert_match /^overriden partial child$/i, @response.body
+  end
+    
+  test "child template and partials are rendered for override" do
+    get :overriden
+    assert_match /^overriden child$/i, @response.body
+    assert_match /^inherited partial base$/i, @response.body
+    assert_match /^overriden partial child$/i, @response.body
+  end
+    
+  test "base template and partials are rendered for inherited format js" do
+    get :inherited, :format => :js
+    assert_match /inherited base js/i, @response.body
+    assert_match /inherited partial base/i, @response.body
+    assert_match /overriden partial child/i, @response.body
+  end
+    
+  test "child template and partials are rendered for override format js" do
+    get :overriden, :format => :js
+    assert_match /overriden child js/i, @response.body
+    assert_match /inherited partial base/i, @response.body
+    assert_match /overriden partial child/i, @response.body
+  end
+  
+end

data/test/templates/test/unit/render_inheritable_test.rb

@@ -0,0 +1,154 @@
+require 'rails'
+require 'test_helper'
+
+TEST_VIEW_PATH = File.join(Rails.root, 'test', 'test_views')
+
+class RootController < ActionController::Base
+  render_inheritable
+  
+  attr_accessor :default_template_format
+  
+  append_view_path(TEST_VIEW_PATH)
+  
+  def initialize(*args)
+    super(*args)
+    self.default_template_format = :html
+  end
+  
+  def view_paths
+    self.class.view_paths
+  end
+  
+end
+
+class ChildrenController < RootController
+  
+end
+
+class GrandChildrenController < ChildrenController
+  
+end
+
+# mock File ojbect
+class File
+  class << self
+    def touched
+      @touched ||= []
+    end
+    
+    alias_method :orig_exists?, :exists?
+    def exists?(filename, *args)
+      touched.include?(filename) || orig_exists?(filename, *args)
+    end
+    
+    def touch_template(file)
+      touched << File.join(ActionController::Base.view_paths.first, "#{file}.html.erb")
+    end
+  end
+end
+
+class RenderInheritableTest < ActiveSupport::TestCase
+ 
+  attr_reader :controller, :grand_controller
+ 
+  def setup
+    teardown
+    @controller = ChildrenController.new
+    @grand_controller = GrandChildrenController.new
+    ChildrenController.send(:inheritable_cache).clear
+    GrandChildrenController.send(:inheritable_cache).clear
+  end
+  
+  def teardown
+    FileUtils.rm_rf(TEST_VIEW_PATH)
+  end
+
+  test "inheritable_root_controller" do
+    assert_equal RootController, RootController.inheritable_root_controller
+    assert_equal RootController, ChildrenController.inheritable_root_controller
+    assert_equal RootController, GrandChildrenController.inheritable_root_controller
+  end
+
+  test "lookup path" do
+    assert_equal ['children', 'root'], ChildrenController.send(:inheritance_lookup_path)
+    assert_equal ['grand_children', 'children', 'root'], GrandChildrenController.send(:inheritance_lookup_path)
+  end
+  
+  test "inheritable controller finds controller instance" do
+    assert_equal 'children', ChildrenController.send(:inheritable_controller)
+    assert_equal 'grand_children', GrandChildrenController.send(:inheritable_controller)
+  end
+    
+  test "find non-existing inheritable file" do
+    assert_nil @controller.send(:find_inheritable_template_folder, 'foo')
+  end
+  
+  test "find inheritable file not overwritten" do
+    touch("root/root.html.erb")
+    
+    assert_equal 'root', @controller.send(:find_inheritable_template_folder, 'root')
+    assert_equal 'root', @grand_controller.send(:find_inheritable_template_folder, 'root')
+  end
+  
+  test "find inheritable file partially overwritten" do
+    touch("root/child.html.erb")
+    touch("children/child.html.erb")
+    
+    assert_equal 'children', @controller.send(:find_inheritable_template_folder, 'child')
+    assert_equal 'children', @grand_controller.send(:find_inheritable_template_folder, 'child')
+  end
+  
+  test "find inheritable file partially overwritten with gaps" do
+    touch("root/grandchild.html.erb")
+    touch("grand_children/grandchild.rhtml")
+    
+    assert_equal 'root', @controller.send(:find_inheritable_template_folder, 'grandchild')
+    assert_equal 'grand_children', @grand_controller.send(:find_inheritable_template_folder, 'grandchild')
+  end
+    
+  test "find inheritable file for js format" do
+    touch("root/_grandchild.js.rjs")
+    touch("grand_children/_grandchild.js.rjs")
+       
+    assert_equal 'root', @controller.send(:find_inheritable_template_folder, 'grandchild', true)
+    assert_equal 'grand_children', @grand_controller.send(:find_inheritable_template_folder, 'grandchild', true)
+        
+    assert_equal({:js => { true => {'grandchild' => {nil => 'root'}}}}, ChildrenController.send(:inheritable_cache))
+    assert_equal({:js => { true => {'grandchild' => {nil => 'grand_children'}}}}, GrandChildrenController.send(:inheritable_cache))
+  end
+  
+  test "find inheritable file for xml format" do
+    touch("root/_grandchild.xml.builder")
+    touch("grand_children/_grandchild.xml.builder")
+    
+    assert_equal 'root', @controller.send(:find_inheritable_template_folder, 'grandchild', true)
+    assert_equal 'grand_children', @grand_controller.send(:find_inheritable_template_folder, 'grandchild', true)
+  end
+  
+  test "find inheritable file all overwritten" do
+    touch("root/all.html.erb")
+    touch("children/all.rhtml")
+    touch("grand_children/all.html.erb")
+    
+    assert_equal 'children', @controller.send(:find_inheritable_template_folder, 'all')
+    assert_equal 'grand_children', @grand_controller.send(:find_inheritable_template_folder, 'all')
+    
+    assert_equal({:html => { false => { 'all' => {nil => 'children'}}}}, ChildrenController.send(:inheritable_cache))
+    assert_equal({:html => { false => { 'all' => {nil => 'grand_children'}}}}, GrandChildrenController.send(:inheritable_cache))
+    
+    assert_equal 'children', @controller.send(:find_inheritable_template_folder, 'all')
+    assert_equal 'grand_children', @grand_controller.send(:find_inheritable_template_folder, 'all')
+    
+    assert_equal({:html => { false => { 'all' => {nil => 'children'}}}}, ChildrenController.send(:inheritable_cache))
+    assert_equal({:html => { false => { 'all' => {nil => 'grand_children'}}}}, GrandChildrenController.send(:inheritable_cache))    
+  end
+
+  private
+  
+  def touch(file)
+    f = File.join(TEST_VIEW_PATH, file)
+    FileUtils.mkdir_p(File.dirname(f))
+    FileUtils.touch(f)
+  end
+  
+end

metadata

@@ -0,0 +1,115 @@
+--- !ruby/object:Gem::Specification 
+name: render_inheritable
+version: !ruby/object:Gem::Version 
+  hash: 11
+  prerelease: false
+  segments: 
+  - 0
+  - 5
+  - 0
+  version: 0.5.0
+platform: ruby
+authors: 
+- Pascal Zumkehr
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-06-23 00:00:00 +02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rails
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        hash: -1848230024
+        segments: 
+        - 3
+        - 0
+        - 0
+        - beta4
+        version: 3.0.0.beta4
+  type: :runtime
+  version_requirements: *id001
+description: |
+  With this gem, a template is searched in the current controller's view folder (as usual). 
+  If it is not found there, the template with the same name in the view folder of the 
+  superclass controller is used. Finally, also views and partials remain DRY!
+
+email: spam@codez.ch
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- MIT-LICENSE
+- README.rdoc
+- VERSION
+files: 
+- lib/rails_integration.rb
+- lib/render_inheritable.rb
+- test/templates/app/config/routes.rb
+- test/templates/app/controllers/base_controller.rb
+- test/templates/app/controllers/child_controller.rb
+- test/templates/app/views/base/_inh_partial.html.erb
+- test/templates/app/views/base/_over_partial.html.erb
+- test/templates/app/views/base/inherited.html.erb
+- test/templates/app/views/base/inherited.js.rjs
+- test/templates/app/views/base/overriden.html.erb
+- test/templates/app/views/base/overriden.js.rjs
+- test/templates/app/views/child/_over_partial.html.erb
+- test/templates/app/views/child/overriden.html.erb
+- test/templates/app/views/child/overriden.js.rjs
+- test/templates/Gemfile
+- test/templates/test/functional/base_controller_test.rb
+- test/templates/test/functional/child_controller_test.rb
+- test/templates/test/unit/render_inheritable_test.rb
+- Rakefile
+- MIT-LICENSE
+- README.rdoc
+- VERSION
+has_rdoc: true
+homepage: http://codez.ch/render_inheritable
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --title
+- Render Inheritable
+- --main
+- README.rdoc
+- --line-numbers
+- --inline-source
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: A Rails 3 plugin that allows one to inherit or override single templates for controller hierarchies.
+test_files: []
+