dry_crud 0.6.0 → 1.0.0

data/README.rdoc

@@ -1,36 +1,42 @@
 = DRY CRUD
 
-Generates simple and extendable controller, views and helpers that support you to DRY up the CRUD code in your Rails project. Start with these elements and build a clean base to efficiently develop your application upon. First, you need to install the gem with
+DRY CRUD generates simple and extendable controller, views and helpers that support you to DRY up the CRUD code in your Rails project. Start with these elements and build a clean base to efficiently develop your application upon. First, you need to install the gem with
 
   gem install dry_crud
 
-Then simply run the following generator in your Rails app to get the goodies:
+In order to use the generator, you have to register the gem in your Rails application's +Gemfile+. Add the following lines:
 
-  script/generate dry_crud
+  group :development, :test do
+    gem 'dry_crud'
+  end
+
+Don't worry, it's a simple development dependency. You may even savely remove it after you have run in once. So now, you should run the generator to get the goodies:
+
+  rails generate dry_crud
+
+To integrate DRY CRUD into your code, only a few additions are required:
 
-To integrate dry_crud into your code, only a few additions are required:
+* For uniform CRUD functionality, just subclass your controllers from +CrudController+. 
+* To use standard formatting, tables and forms throughout your application, add <tt>helper :standard</tt> to your +ApplicationController+ and benefit everywhere from these little helper methods. 
+* Add a <tt>:label</tt> method to your models for a human-friendly representation.
 
-* To use a standard formatting, tables and forms throughout your application, add 'helper :standard' to your ApplicationController. 
-* To get uniform CRUD functionallity, just subclass your controllers from CrudController. 
-* Add a :label method to your models for a human-friendly representation.
+Version 1.0.0 is built for Rails 3. If you need a version for Rails 2.3, please get version 0.6.0 of the gem or go to the rails-2.3 branch on Github.
 
 == Overview
 
-In most Rails applications, you have some models that require basic CRUD (create, read, update, delete) functionality. There are various possibilities like Rails scaffolding, {Active Scaffold}[http://activescaffold.com/] or {Dry Scalffold}[http://github.com/grimen/dry_scaffold]. Still, various parts in your application remain duplicated. While you might pull up common methods into a common superclass controller, most views still contain very similar code.
+In most Rails applications, you have some models that require basic CRUD (create, read, update, delete) functionality. There are various possibilities like Rails scaffolding, {Active Scaffold}[http://activescaffold.com/] or {Dry Scaffold}[http://github.com/grimen/dry_scaffold]. Still, various parts in your application remain duplicated. While you might pull up common methods into a common superclass controller, most views still contain very similar code.
 
 Enter DRY CRUD.
 
 <b>
-The main idea of DRY CRUD is to concentrate basic functionality of your application, like CRUD actions, uniform formatting, forms and tables into specifically extendable units. DRY CRUD generates various foundation classes that you may freely adapt to your application's needs. For each model, you may transparently customize arbitrary parts or just fallback to the general behaviour. This applies not only for controllers, but also for view templates and helpers.
+The main idea of DRY CRUD is to concentrate basic functionality of your application, like CRUD actions, uniform formatting, forms and tables into specifically extendable units. DRY CRUD generates various foundation classes that you may freely adapt to your application's needs. For each model, you may transparently customize arbitrary parts or just fallback to the general behavior. This applies not only for controllers, but also for view templates and helpers.
 </b>
 
-A core element of DRY CRUD is the RenderInheritable module. This gives you inheritable views and partials. 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. This lookup path might be customized as well.
+A core element of DRY CRUD is the +RenderInheritable+ module. This gives you inheritable views and partials. 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. This lookup path might be customized as well. RenderInheritable is also available as a stand-alone gem at http://github.com/codez/render_inheritable.
 
 DRY CRUD is a Rails generator. All code resides in your application and is open for you to inspect and to extend. You may pick whatever you consider useful or adapt what is not sufficient. Even if you do not require any CRUD functionality, you might find some helpers simplifying your work. There are no runtime dependencies to the dry_crud gem. Having said this, DRY CRUD does not want to provide a maximum of functionality that requires a lot of configuration, but rather a clean and lightweight foundation to build your application's requirements upon. This is why DRY CRUD comes as a generator and not as a Rails plugin.
 
-DRY CRUD does not depend on any other plugins, but easily allows you to integrate them in order to unify the behaviour of your CRUD controllers. You might even use the plugins mentioned above to adapt your generated CrudController base class. All classes come with thorough tests that provide you with a solid foundation for implementing your own adaptions.
-
-The gem was developped with Rails 2.3.8, we plan to reach a fully compatible version 1.0 when Rails 3 has come out.
+DRY CRUD does not depend on any other plugins, but easily allows you to integrate them in order to unify the behavior of your CRUD controllers. You might even use the plugins mentioned above to adapt your generated +CrudController+ base class. All classes come with thorough tests that provide you with a solid foundation for implementing your own adaptions.
 
 See the Examples section for some use cases and the Generated Files section below for details on the single classes and templates.
 
@@ -38,7 +44,7 @@ See the Examples section for some use cases and the Generated Files section belo
 
 === Controller with CRUD functionality
 
-Say you want to manage a Person model. Create the following controller and add a :label method to your model for a human-friendly representation used in page titles.
+Say you want to manage a +Person+ model. Create the following controller and add a <tt>:label</tt> method to your model for a human-friendly representation used in page titles.
 
 <tt>app/controllers/people_controller.rb</tt>:
   class PeopleController < CrudController
@@ -51,21 +57,21 @@ Say you want to manage a Person model. Create the following controller and add a
     end
   end
 
-That's it. You have an overview of all people, detail pages and forms to edit and create persons. Oh, and of course, you may delete persons as well. By default, all attributes are displayed and formatted according to their column type whereever they appear. This holds for the input fields as well.
+That's it. You have an overview of all people, detail pages and forms to edit and create persons. Oh, and of course, you may delete persons as well. By default, all attributes are displayed and formatted according to their column type wherever they appear. This holds for the input fields as well.
 
 
 ==== Customize single views
 
-Well, maybe there are certain attributes you do not want to display in the people list, or others that are not editable. No problem, simply create a <tt>list</tt> partial in <tt>app/views/people/_list.html.erb</tt> to customize this:
+Well, maybe there are certain attributes you do not want to display in the people list, or others that are not editable. No problem, simply create a <tt> _list</tt> partial in <tt>app/views/people/_list.html.erb</tt> to customize this:
 
   <%= crud_table [:lastname, :firstname, :city, :sex] %>
 
 This only displays these three attributes in the table. All other templates, as well as the main index view, fallback to the ones in <tt>app/views/crud</tt>.
 
 
-==== Adapt general behaviour
+==== Adapt general behavior
 
-Next, let's adapt a part of the general behaviour used in all CRUD controllers. As an example, we include pagination with will_paginate[http://wiki.github.com/mislav/will_paginate/] in all our overview tables: 
+Next, let's adapt a part of the general behavior used in all CRUD controllers. As an example, we include pagination with will_paginate[http://wiki.github.com/mislav/will_paginate/] in all our overview tables: 
 
 In <tt>app/controllers/crud_controller.rb</tt>, change the index action to
 
@@ -77,19 +83,19 @@ In <tt>app/controllers/crud_controller.rb</tt>, change the index action to
 In <tt>app/views/crud/index.html.erb</tt>, add the following line for the pagination links:
    <%= will_paginate @entries %>
 
-And we are done again. All our controllers inheriting from CrudController, including above PeopleController, now have paginated index views. Because our customization for the people table is in the seperate <tt>_list</tt> partial, no further modifications are required. 
+And we are done again. All our controllers inheriting from +CrudController+, including above +PeopleController+, now have paginated index views. Because our customization for the people table is in the separate <tt> _list</tt> partial, no further modifications are required. 
 
 
 ==== Special formatting for selected attributes
 
-Sometimes, the default formatting provided by :format_attr will not be sufficient. We have a boolean column <tt>sex</tt> in our model, but would like to display 'male' or 'female' for it (instead of 'no' or 'yes', which is a bit cryptic). Just define a method in your view helper starting with <tt>format_</tt>, followed by the attribute name:
+Sometimes, the default formatting provided by +:format_attr+ will not be sufficient. We have a boolean column <tt>sex</tt> in our model, but would like to display 'male' or 'female' for it (instead of 'no' or 'yes', which is a bit cryptic). Just define a method in your view helper starting with <tt>format_</tt>, followed by the attribute name:
 
 In <tt>app/helpers/people.rb</tt>:
   def format_sex(person)
     person.sex ? 'female' : 'male'
   end
 
-By the way: The method :f in StandardHelper uniformly formats arbitrary values according to their class.  
+By the way: The method +:f+ in +StandardHelper+ uniformly formats arbitrary values according to their class.  
 
 
 ==== CRUD controller callbacks
@@ -114,11 +120,11 @@ In <tt>app/controllers/people_controller.rb</tt>:
 
 === Standard Tables and Forms
 
-DRY CRUD also provides two builder classes for update/create forms and tables for displaying entries of one model. They may be used allover your application to DRY up the form and table code. Normally, they are used with the corresponding methods from StandardHelper.
+DRY CRUD also provides two builder classes for update/create forms and tables for displaying entries of one model. They may be used all over your application to DRY up the form and table code. Normally, they are used with the corresponding methods from +StandardHelper+.
 
 ==== Tables
 
-This is the code to define a table with some attribue columns for a list of same-type entries. Columns get a header corresponding to the attribute name:
+This is the code to define a table with some attribute columns for a list of same-type entries. Columns get a header corresponding to the attribute name:
   <%= table(@people) do |t|
         t.attrs :lastname, :firstname
       end %>
@@ -156,14 +162,22 @@ All generated files are supposed to provide a reasonable foundation for the CRUD
 
 === Controller:
 
-{controller/crud_controller.rb}[http://codez.ch/dry_crud/?q=CrudController]:: Abstract controller providing basic CRUD actions in a RESTful way. This implementation mainly follows the one of the Rails scaffolding controller. Some enhancements were made to ease extendability. Several protected helper methods are there to be (optionally) overriden by subclasses.
+{controller/crud_controller.rb}[http://codez.ch/dry_crud/?q=CrudController]:: Abstract controller providing basic CRUD actions. This implementation mainly follows the one of the Rails scaffolding controller and responses to HTML and XML requests. Some enhancements were made to ease extendability. Several protected helper methods are there to be (optionally) overriden by subclasses. With the help of additional callbacks, it is possible to hook into the action procedures without overriding the entire method.
+
+{controller/render_inheritable.rb}[http://codez.ch/dry_crud/?q=RenderInheritable]:: A controller enhancement that 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. Thus, only views or partials that look differently have to be overwritten.
+
 
 === Helpers:
 
-{helpers/standard_helper.rb}[http://codez.ch/dry_crud/?q=StandardHelper]:: A view helper to standartize often used functions like formatting, tables, forms or action links. This helper is ideally defined in the ApplicationController. It is required to use the StandardTableBuilder and the StandardFormBuilder.
+{helpers/standard_helper.rb}[http://codez.ch/dry_crud/?q=StandardHelper]:: A view helper to standardize often used functions like formatting, tables, forms or action links. This helper is ideally defined in the ApplicationController. It is required to use the StandardTableBuilder and the StandardFormBuilder.
 
 {helpers/crud_helper.rb}[http://codez.ch/dry_crud/?q=CrudHelper]:: A small helper for CrudController to render tables and forms with a default set of attributes.
 
+{helpers/standard_table_builder.rb}[http://codez.ch/dry_crud/?q=StandardTableBuilder]:: A simple helper object to easily define tables listing several rows of the same data type.
+
+{helpers/standard_form_builder.rb}[http://codez.ch/dry_crud/?q=StandardFormBuilder]:: A form builder that automatically selects the corresponding input element for ActiveRecord columns. Input elements are rendered with a corresponding label by default.
+
+
 === Views:
 
 views/crud/index.html.erb:: The index view displaying a table with all entries and an action link to add new ones.
@@ -184,23 +198,14 @@ views/shared/_labeled.html.erb:: Partial to define the layout for an arbitrary c
 
 views/layouts/crud.html.erb:: An example layout showing how to use the @title and +flash+. Most probably you want to include this in your application.html.erb or adapt this main crud templates, so you wont need this file.
 
-public/stylesheets/crud.css:: A simple CSS with all the classes and ids used in the crud code. 
-
-=== Lib:
-
-{lib/standard_table_builder.rb}[http://codez.ch/dry_crud/?q=StandardTableBuilder]:: A simple helper to easily define tables listing several rows of the same data type.
-
-{lib/standard_form_builder.rb}[http://codez.ch/dry_crud/?q=StandardFormBuilder]:: A form builder that automatically selects the corresponding input element for ActiveRecord columns. Input elements are rendered with a corresponding label by default.
-
-{lib/render_inheritable.rb}[http://codez.ch/dry_crud/?q=RenderInheritable]:: 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. Thus, only views or partials that look differently have to be overwritten.
+public/stylesheets/crud.css:: A simple CSS with all the classes and ids used in the CRUD code. 
 
-{lib/crud_callbacks.rb}[http://codez.ch/dry_crud/?q=CrudCallbacks]:: Defines before and after callback hooks for create, update, save and destroy. When to execute the callbacks is in the responsibility of the clients of this module. This module is used in the CrudController to provide callbacks.
 
 === Tests:
 
 test/crud_test_model.rb:: A dummy model to run CRUD tests against.
 
-{test/functionals/crud_controller_test_helper.rb}[http://codez.ch/dry_crud/?q=CrudControllerTestHelper]:: A module to include into the functional tests for your CrudController subclasses. Contains a handfull of CRUD functionality tests for the provided implementation. So for each new crud controller, you get 20 tests for free.
+{test/functionals/crud_controller_test_helper.rb}[http://codez.ch/dry_crud/?q=CrudControllerTestHelper]:: A module to include into the functional tests for your CrudController subclasses. Contains a handful of CRUD functionality tests for the provided implementation. So for each new CRUD controller, you get 20 tests for free.
 
 test/several other tests:: Testing the provided implementation and a great base to test your adaptions of the CRUD code.
 

data/Rakefile

@@ -2,46 +2,50 @@ require 'rubygems'
 require "rake/testtask"
 require 'rake/gempackagetask' 
 require 'rake/rdoctask' 
-sdoc = (require 'sdoc' || true) rescue false
+sdoc = begin 
+  require 'sdoc'
+  true
+rescue Exception
+  false
+end
 
-load	'dry_crud.gemspec'
+load 'dry_crud.gemspec'
 
 TEST_APP_ROOT  = File.join(File.dirname(__FILE__), 'test', 'test_app')
-GENERATOR_ROOT = File.join(File.dirname(__FILE__), 'rails_generators', 'dry_crud')
+GENERATOR_ROOT = File.join(File.dirname(__FILE__), 'lib', 'generators', 'dry_crud')
 
 task :default => :test
 
 desc "Run all tests"
 task :test => ['test:app:init'] do
-	Rake::TestTask.new do |test| 
-		test.libs << "test/test_app/test" 
-		test.test_files = Dir[ "test/test_app/test/**/*_test.rb" ] 
-		test.verbose = true
-	end
+  Rake::TestTask.new do |test| 
+    test.libs << "test/test_app/test" 
+    test.test_files = Dir[ "test/test_app/test/**/*_test.rb" ] 
+    test.verbose = true
+  end
 end
 
 namespace :test do
-	namespace :app do
+  namespace :app do
     task :environment do
-      ::RAILS_ROOT = TEST_APP_ROOT
-      ::RAILS_ENV = 'test'
+      ENV['RAILS_ROOT'] = TEST_APP_ROOT
+      ENV['RAILS_ENV'] = 'test'
       
       require(File.join(TEST_APP_ROOT, 'config', 'environment'))
     end
   
-		desc "Create a rails test application"
-		task :create do
-			unless File.exist?(TEST_APP_ROOT)
-				sh "rails #{TEST_APP_ROOT}"
-			end
-	  end
+    desc "Create a rails test application"
+    task :create do
+      unless File.exist?(TEST_APP_ROOT)
+        sh "rails new #{TEST_APP_ROOT}"
+      end
+    end
       
     desc "Run the dry_crud generator for the test application"
     task :generate_crud => [:create, :environment] do
-      require 'rails_generator'
       require File.join(GENERATOR_ROOT, 'dry_crud_generator')
     
-      Rails::Generator::Spec.new('dry_crud', GENERATOR_ROOT, :RubyGems).klass.new([], :collision => :force).command(:create).invoke!
+      DryCrudGenerator.new('', {:force => true}, :destination_root => TEST_APP_ROOT).invoke_all
     end
    
     desc "Initializes the test application with a couple of classes"
@@ -51,51 +55,55 @@ namespace :test do
         sh "rake db:migrate db:test:prepare"
       end
     end
-	end
+  end
 end
 
 desc "Clean up all generated resources"
 task :clobber do
-	FileUtils.rm_rf(TEST_APP_ROOT)
+  FileUtils.rm_rf(TEST_APP_ROOT)
 end
 
 desc "Install dry_crud 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/dry_crud-#{File.read('VERSION').strip}}
+  sudo = RUBY_PLATFORM =~ /win32/ ? '' : 'sudo' 
+  gem = RUBY_PLATFORM =~ /java/ ? 'jgem' : 'gem' 
+  sh %{#{sudo} #{gem} install --no-ri pkg/dry_crud-#{File.read('VERSION').strip}}
 end
 
 desc "Deploy rdoc to website"
 task :site => :rdoc do
-  sh "rsync -rzv rdoc/ #{ENV['DEST']}"
+  if ENV['DEST']
+  	sh "rsync -rzv rdoc/ #{ENV['DEST']}"
+  else
+  	puts "Please specify a destination with DEST=user@server:/deploy/dir"
+  end
 end
 
 # :package task
 Rake::GemPackageTask.new(DRY_CRUD_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 
+  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	= 'Dry Crud' 
-	rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.title  = 'Dry Crud' 
+  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('rails_generators/dry_crud/templates/**/*.rb') 
-  rdoc.rdoc_files.exclude('rails_generators/dry_crud/templates/**/*_test.rb') 
-	rdoc.rdoc_files.exclude('TODO') 
-		
-	rdoc.rdoc_dir = 'rdoc'
-	rdoc.main = 'README.rdoc' 
-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('generators/dry_crud/templates/**/*.rb') 
+  rdoc.rdoc_files.exclude('generators/dry_crud/templates/**/*_test.rb') 
+  rdoc.rdoc_files.exclude('TODO') 
+    
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.main = 'README.rdoc' 
+end

data/VERSION

@@ -1 +1 @@
-0.6.0
+1.0.0

data/lib/generators/dry_crud/USAGE

@@ -0,0 +1 @@
+rails g dry_crud

data/lib/generators/dry_crud/dry_crud_generator.rb

@@ -0,0 +1,20 @@
+require 'rails/generators'
+
+class DryCrudGenerator < Rails::Generators::Base
+  
+  def self.source_root
+     File.join(File.dirname(__FILE__), 'templates')
+  end
+  
+  def install_dry_crud
+    # copy everything in template subfolders
+    Dir.chdir(self.class.source_root) do
+      Dir.glob("*").each do |f|
+        directory(f) if File.directory?(f)
+      end
+    end
+    
+    readme "INSTALL"
+  end
+
+end

data/{rails_generators → lib/generators}/dry_crud/templates/INSTALL

@@ -3,10 +3,11 @@ Thank you for using dry_crud. Feel free to adapt all generated classes to
 your needs. To integrate dry_crud into your code, only a few additions are 
 required:
 
- * To use a standard formatting, tables and forms throught your application, 
-   add 'helper :standard' to your ApplicationController. 
- * To get uniform CRUD functionallity, just subclass your controllers from 
+ * For uniform CRUD functionallity, just subclass your controllers from 
    CrudController. 
+ * To use standard formatting, tables and forms throughout your
+   application, add 'helper :standard' to your ApplicationController and 
+   benefit everywhere from these little helper methods. 
  * Add a :label method to your models for a human-friendly representation.
 
 Enjoy dry_crud and stay DRY!

data/{rails_generators → lib/generators}/dry_crud/templates/app/controllers/crud_controller.rb

@@ -1,24 +1,40 @@
 # Abstract controller providing basic CRUD actions.
 # This implementation mainly follows the one of the Rails scaffolding
-# controller. Some enhancements were made to ease extendability.
+# controller and responses to HTML and XML requests. Some enhancements were made to ease extendability.
 # Several protected helper methods are there to be (optionally) overriden by subclasses.
+# With the help of additional callbacks, it is possible to hook into the action procedures without
+# overriding the entire method.
 class CrudController < ApplicationController
   
-  include CrudCallbacks
   include RenderInheritable 
   
+  extend ActiveModel::Callbacks
+   
+  # Defines before and after callback hooks for create, update, save and destroy.
+  define_model_callbacks :create, :update, :save, :destroy
+  
+  # Defines before callbacks for the render actions.
+  define_model_callbacks :render_index, 
+                         :render_show, 
+                         :render_new, 
+                         :render_edit, 
+                         :only => :before,
+                         :terminator => "result == false || performed?"
+  
   delegate :model_class, :model_identifier, :models_label, :to => 'self.class'  
 
   # Verify that required :id param is present and only allow good http methods.
-  verify :params => :id, :only => :show, :redirect_to => { :action => 'index' }
-  verify :method => :post, :only => :create,  :redirect_to => { :action => 'index' }  
-  verify :method => [:put, :post], :params => :id, :only => :update,  :redirect_to => { :action => 'index' }  
-  verify :method => [:delete, :post], :params => :id, :only => :destroy, :redirect_to => { :action => 'index' }  
+  # Uncomment if you have the Rails verification plugin installed.
+  #verify :params => :id, :only => :show, :redirect_to => { :action => 'index' }
+  #verify :method => :post, :only => :create,  :redirect_to => { :action => 'index' }  
+  #verify :method => [:put, :post], :params => :id, :only => :update,  :redirect_to => { :action => 'index' }  
+  #verify :method => [:delete, :post], :params => :id, :only => :destroy, :redirect_to => { :action => 'index' }  
   
   # Set up entry object to use in the various actions.
   before_filter :build_entry, :only => [:new, :create]
   before_filter :set_entry,   :only => [:show, :edit, :update, :destroy]
   
+  helper :standard
   helper_method :model_class, :models_label, :full_entry_label
   
   hide_action :model_class, :models_label, :model_identifier, :run_callbacks, :inheritable_root_controller
@@ -152,8 +168,8 @@ class CrudController < ApplicationController
   # Helper method to run before_render callbacks and render the action.
   # If a callback renders or redirects, the action is not rendered.
   def render_with_callback(action)
-    render_callbacks(action)
-    render_inheritable :action => action unless performed?
+    run_callbacks(:"render_#{action}")
+    render :action => action unless performed?
   end
   
   # Saves the current entry with callbacks.
@@ -161,6 +177,12 @@ class CrudController < ApplicationController
     with_callbacks(:save) { @entry.save }
   end   
   
+  # Helper method the run the given block in between the before and after
+  # callbacks of the given kind.
+  def with_callbacks(kind, &block)
+    send(:"_run_#{kind}_callbacks", &block)
+  end
+  
   class << self
     # The ActiveRecord class of the model.
     def model_class
@@ -175,7 +197,7 @@ class CrudController < ApplicationController
     
     # A human readable plural name of the model.
     def models_label
-      @models_label ||= model_class.human_name.pluralize
+      @models_label ||= model_class.model_name.human.pluralize
     end   
   end
   

data/lib/generators/dry_crud/templates/app/controllers/render_inheritable.rb

@@ -0,0 +1,152 @@
+# 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)
+      descendants = inheritable_root_controller.descendants
+      c = find_inheritable_artifact(param) do |folder|
+      	descendants.any? { |s| s.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/{rails_generators → lib/generators}/dry_crud/templates/app/helpers/crud_helper.rb

@@ -5,12 +5,12 @@ module CrudHelper
   
   # Create a table of the @entries variable with the default or 
   # the passed attributes in its columns.
-  def crud_table(attrs = nil, &block)
+  def crud_table(*attrs, &block)
     if block_given?
-      table(@entries, &block)
+      table(@entries, *attrs, &block)
     else
-      table(@entries) do |t|
-        t.attrs(*(attrs || default_attrs))
+      attributes = attrs.present? ? attrs : default_attrs
+      table(@entries, *attributes) do |t|
         add_list_actions(t)
       end
     end