dry_crud 0.6.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,208 @@
+= 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:
+
+  script/generate dry_crud
+
+To integrate dry_crud into your code, only a few additions are required:
+
+* 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.
+
+== 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.
+
+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.
+</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.
+
+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.
+
+See the Examples section for some use cases and the Generated Files section below for details on the single classes and templates.
+
+== Examples
+
+=== 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.
+
+<tt>app/controllers/people_controller.rb</tt>:
+  class PeopleController < CrudController
+  end
+
+<tt>app/models/person.rb</tt>:
+  class Person
+    def label
+      "#{lastname} #{firstname}"
+    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.
+
+
+==== 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:
+
+  <%= 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
+
+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: 
+
+In <tt>app/controllers/crud_controller.rb</tt>, change the index action to
+
+  def index
+    @entries = model_class.paginate({:page => params[:page]}.merge(find_all_options)) 
+    respond_with @entries   
+  end
+
+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. 
+
+
+==== 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:
+
+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.  
+
+
+==== CRUD controller callbacks
+
+As a last example, let's say we have added a custom input field that must specially processed. Instead of overwriting the entire update action, it is possible to register callbacks for the +create+, +update+, +save+ (= +create+ and +update+) and +destroy+ actions. They work very similarliy like the callbacks on ActiveRecord. For each action, before and after callbacks are run. Before callbacks may also prevent the action from being executed when returning false. Here is some code:
+
+In <tt>app/controllers/people_controller.rb</tt>:
+  after_save :upload_picture
+  before_destroy :delete_picture
+	
+  def upload_picture
+    store_file(params[:person][:picture]) if params[:person][:picture]
+  end
+  
+  def delete_picture
+    if !perform_delete_picture(@entry.picture)
+      flash[:error] = 'Could not delete picture' 
+      false
+    end
+  end
+
+
+=== 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.
+
+==== 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:
+  <%= table(@people) do |t|
+        t.attrs :lastname, :firstname
+      end %>
+
+If entries is empty, a basic 'No entries available' message is rendered instead of the table.
+
+To render custom columns, use the :col method:
+  <%= table(@people) do |t|
+        t.attrs :lastname, :firstname
+        t.col('', :class => 'center') {|entry| image_tag(entry.picture) }
+        t.attrs :street        
+        t.col('Map') {|entry| link_to(entry.city, "http://maps.google.com/?q=#{entry.city}" }
+      end %>
+
+==== Forms
+
+Forms work very similar. In the most simple case, you just have to specify which attributes of a model to create input fields for, and you get a complete form with error messages, labeled input fields according the column types and a save button:
+
+  <% form(@person, [:firstname, :lastname, :age, :city] -%>
+
+Of course, custom input fields may be defined as well:
+  <% form(@person, [], :url => {:action => 'custom_update', :id => @person.id}) do |f| -%>
+    <%= f.labeled_input_fields :firstname, :lastname %>
+    <% f.labeled(:sex) do %>
+      <%= f.radio_button :sex, true %> female
+      <%= f.radio_button :sex, false %> male
+    <% end -%>
+    <%= f.labeled_integer_field :age %>
+    <%= f.labeled_file_field :picture %>
+  <% end -%>
+
+== Generated Files
+
+All generated files are supposed to provide a reasonable foundation for the CRUD functionality. You are encouraged to adapt them to fit the needs of your application. They're yours!
+
+=== 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.
+
+=== 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/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.
+
+=== Views:
+
+views/crud/index.html.erb:: The index view displaying a table with all entries and an action link to add new ones.
+
+views/crud/_list.html.erb:: A partial defining the table in the index view. To change the displayed attributes in your CRUD model, just create an own _list.html.erb in your models view directory.
+
+views/crud/show.html.erb:: The show view displaying all the attributes of one entry and the various actions to perform on it.
+
+views/crud/_attrs.html.erb:: A partial defining the attributes to be displayed in the show view. 
+
+views/crud/new.html.erb:: The view to create a new entry.
+
+views/crud/edit.html.erb:: The view to edit an existing entry.
+
+views/crud/_form.html.erb:: The form used to create and edit entries. If you would like to customize this form for various models, just create an own _form.html.erb in your models view directory.
+
+views/shared/_labeled.html.erb:: Partial to define the layout for an arbitrary content with a label.
+
+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.
+
+{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/several other tests:: Testing the provided implementation and a great base to test your adaptions of the CRUD code.
+
+
+

data/Rakefile

@@ -0,0 +1,101 @@
+require 'rubygems'
+require "rake/testtask"
+require 'rake/gempackagetask' 
+require 'rake/rdoctask' 
+sdoc = (require 'sdoc' || true) rescue false
+
+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')
+
+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
+end
+
+namespace :test do
+	namespace :app do
+    task :environment do
+      ::RAILS_ROOT = TEST_APP_ROOT
+      ::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 "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!
+    end
+   
+    desc "Initializes the test application with a couple of classes"
+    task :init => :generate_crud 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
+	end
+end
+
+desc "Clean up all generated resources"
+task :clobber do
+	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}}
+end
+
+desc "Deploy rdoc to website"
+task :site => :rdoc do
+  sh "rsync -rzv rdoc/ #{ENV['DEST']}"
+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 
+end
+
+# :rdoc task
+Rake::RDocTask.new do |rdoc| 
+	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

data/VERSION

@@ -0,0 +1 @@
+0.6.0

data/rails_generators/dry_crud/USAGE

@@ -0,0 +1 @@
+script/generate dry_crud

data/rails_generators/dry_crud/dry_crud_generator.rb

@@ -0,0 +1,22 @@
+class DryCrudGenerator < Rails::Generator::Base
+	
+	def manifest
+		record do |m|
+			# copy everything in template subfolders
+			Dir.chdir(File.join(File.dirname(__FILE__), 'templates')) do
+				Dir.glob("*/**/*").each do |f|
+					if File.directory?(f)
+						m.directory f
+					else
+						m.file f, f
+					end
+				end
+			end
+			
+			#m.template src, dst
+			
+			m.readme "INSTALL"
+		end
+	end
+
+end

data/rails_generators/dry_crud/templates/INSTALL

@@ -0,0 +1,13 @@
+
+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 
+   CrudController. 
+ * Add a :label method to your models for a human-friendly representation.
+
+Enjoy dry_crud and stay DRY!
+ 

data/rails_generators/dry_crud/templates/app/controllers/crud_controller.rb

@@ -0,0 +1,182 @@
+# Abstract controller providing basic CRUD actions.
+# 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.
+class CrudController < ApplicationController
+  
+  include CrudCallbacks
+  include RenderInheritable 
+  
+  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' }  
+  
+  # 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_method :model_class, :models_label, :full_entry_label
+  
+  hide_action :model_class, :models_label, :model_identifier, :run_callbacks, :inheritable_root_controller
+  
+   
+  ##############  ACTIONS  ############################################
+  
+  # List all entries of this model.
+  #   GET /entries
+  #   GET /entries.xml
+  def index
+    @entries = model_class.all find_all_options
+    respond_with @entries
+  end
+  
+  # Show one entry of this model.
+  #   GET /entries/1
+  #   GET /entries/1.xml
+  def show
+    respond_with @entry
+  end
+  
+  # Display a form to create a new entry of this model.
+  #   GET /entries/new
+  #   GET /entries/new.xml
+  def new
+    respond_with @entry
+  end
+  
+  # Display a form to edit an exisiting entry of this model.
+  #   GET /entries/1/edit
+  def edit
+    render_with_callback :edit
+  end
+  
+  # Create a new entry of this model from the passed params.
+  #   POST /entries
+  #   POST /entries.xml
+  def create
+    created = with_callbacks(:create) { save_entry } 
+    
+    respond_processed(created, 'created', 'new') do |format|
+      format.html { redirect_to_show }
+      format.xml  { render :xml => @entry, :status => :created, :location => @entry }
+    end
+  end
+  
+  # Update an existing entry of this model from the passed params.
+  #   PUT /entries/1
+  #   PUT /entries/1.xml
+  def update
+    @entry.attributes = params[model_identifier]
+    updated = with_callbacks(:update) { save_entry }
+    
+    respond_processed(updated, 'updated', 'edit') do |format|
+      format.html { redirect_to_show }
+      format.xml  { head :ok }
+    end
+  end
+  
+  # Destroy an existing entry of this model.
+  #   DELETE /entries/1
+  #   DELETE /entries/1.xml
+  def destroy
+    destroyed = with_callbacks(:destroy) { @entry.destroy }
+    
+    respond_processed(destroyed, 'destroyed', 'show') do |format|
+      format.html { redirect_to_index }
+      format.xml  { head :ok }
+    end
+  end
+  
+  protected 
+  
+  #############  CUSTOMIZABLE HELPER METHODS  ##############################
+  
+  # Convenience method to respond to various formats with the given object.
+  def respond_with(object)
+    respond_to do |format|
+      format.html { render_with_callback action_name }
+      format.xml  { render :xml => object }
+    end
+  end
+  
+  # Convenience method to respond to various formats if the performed
+  # action may succeed or fail. In case of failure, a standard response
+  # is given and the failed_action template is rendered. In case of success,
+  # the flash[:notice] is set and control is passed to the given block.
+  def respond_processed(success, operation, failed_action)
+    respond_to do |format|
+      if success
+        flash[:notice] = "#{full_entry_label} was successfully #{operation}."
+        yield format
+      else 
+        format.html { render_with_callback failed_action }
+        format.xml  { render :xml => @entry.errors, :status => :unprocessable_entity }
+      end
+    end
+  end
+  
+  # Creates a new model entry from the given params.
+  def build_entry        
+    @entry = model_class.new(params[model_identifier])
+  end
+  
+  # Sets an existing model entry from the given id.
+  def set_entry
+    @entry = model_class.find(params[:id])
+  end     
+  
+  # A label for the current entry, including the model name.
+  def full_entry_label        
+	  "#{models_label.singularize} '#{@entry.label}'"
+  end    
+  
+  # Find options used in the index action.
+  def find_all_options
+    {}
+  end
+  
+  # Redirects to the show action of a single entry.
+  def redirect_to_show
+    redirect_to @entry
+  end
+  
+  # Redirects to the main action of this controller.
+  def redirect_to_index
+    redirect_to :action => 'index'
+  end
+   
+  # 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?
+  end
+  
+  # Saves the current entry with callbacks.
+  def save_entry       
+    with_callbacks(:save) { @entry.save }
+  end   
+  
+  class << self
+    # The ActiveRecord class of the model.
+    def model_class
+      @model_class ||= controller_name.classify.constantize
+    end
+    
+    # The identifier of the model used for form parameters.
+    # I.e., the symbol of the underscored model name.
+    def model_identifier
+      @model_identifier ||= model_class.name.underscore.to_sym
+    end
+    
+    # A human readable plural name of the model.
+    def models_label
+      @models_label ||= model_class.human_name.pluralize
+    end   
+  end
+  
+end

data/rails_generators/dry_crud/templates/app/helpers/crud_helper.rb

@@ -0,0 +1,45 @@
+# Extension of StandardHelper functionality to provide a set of default 
+# attributes for the current model to be used in tables and forms. This helper
+# is included in CrudController.
+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)
+    if block_given?
+      table(@entries, &block)
+    else
+      table(@entries) do |t|
+        t.attrs(*(attrs || default_attrs))
+        add_list_actions(t)
+      end
+    end
+  end
+  
+  # Adds a set of standard action link column (show, edit, destroy) to the given table.
+  def add_list_actions(table)
+    table.col { |e| link_action_show(e) }
+    table.col { |e| link_action_edit(e) }
+    table.col { |e| link_action_destroy(e) }
+  end
+  
+  # Renders a generic form for the current entry with :default_attrs or the 
+  # given attribute array, using the StandardFormBuilder.
+  # If a block is given, a custom form may be rendered and attrs is ignored.
+  def crud_form(attrs = nil, options = {}, &block)
+    unless attrs
+      attrs = default_attrs
+      [:created_at, :updated_at].each {|a| attrs.delete(a) }
+    end		
+    standard_form(@entry, attrs, &block)
+  end
+  
+  # The default attributes to use in attrs, list and form partials.
+  # These are all defined attributes except certain special ones like 'id' or 'position'.
+  def default_attrs	
+    attrs = model_class.column_names.collect(&:to_sym)
+    [:id, :position].each {|a| attrs.delete(a) }
+    attrs
+  end
+  
+end