resouce_this
===========

Not scaffolding. Resourcing. Creates extremely customizable resource controllers with one line of code.

  class PostsController < ActionController::Base
   resource_this
  end

...will generate the following code:

  class PostsController < ActionController::Base
    before_filter :load_post, :only => [ :show, :edit, :update, :destroy ]
    before_filter :load_posts, :only => [ :index ]
    before_filter :new_post, :only => [ :new ]
    before_filter :create_post, :only => [ :create ]
    before_filter :update_post, :only => [ :update ]
    before_filter :destroy_post, :only => [ :destroy ]

  protected
    def load_post
      @post = Post.find(params[:id])
    end
  
    def new_post
      @post = Post.new
    end
  
    def create_post
      returning true do
        @post = Post.new(params[:post])
        @created = @post.save
      end
    end
  
    def update_post
      returning true do
        @updated = @post.update_attributes(params[:post])
      end
    end
  
    def destroy_post
      @post = @post.destroy
    end
  
    def load_posts
      @posts = Post.find(:all)
    end
  
  public
    def index
      respond_to do |format|
        format.html
        format.xml  { render :xml => @posts }
        format.js
      end
    end

    def show          
      respond_to do |format|
        format.html
        format.xml  { render :xml => @post }
        format.js
      end
    end

    def new          
      respond_to do |format|
        format.html { render :action => :edit }
        format.xml  { render :xml => @post }
        format.js
      end
    end

    def create
      respond_to do |format|
        if @created
          flash[:notice] = 'Post was successfully created.'
          format.html { redirect_to @post }
          format.xml  { render :xml => @post, :status => :created, :location => @post }
          format.js
        else
          format.html { render :action => :new }
          format.xml  { render :xml => @post.errors, :status => :unprocessable_entity }
          format.js
        end
      end
    end 

    def edit
      respond_to do |format|
        format.html
        format.js
      end
    end

    def update
      respond_to do |format|
        if @updated
          flash[:notice] = 'Post was successfully updated.'
          format.html { redirect_to @post }
          format.xml  { head :ok }
          format.js
        else
          format.html { render :action => :edit }
          format.xml  { render :xml => @post.errors, :status => :unprocessable_entity }
          format.js
        end
      end
    end

    def destroy          
      respond_to do |format|
        format.html { redirect_to :action => posts_url }
        format.xml  { head :ok }
        format.js
      end
    end
  end

Nested resources like so:

  class CommentsController < ActionController::Base
    resource_this :nested => [:posts]
  end

This generates a very similar controller to the one above with adjusted redirects and one additional before_filter / 
loader method pair to grab the parent resource. In this case:

  before_filter :load_post
  
  def load_post
    @post = Post.find(params[:post_id])
  end
  
The separation of logic - DB operations in before_filters, rendering in the standard resource controller methods - makes 
this approach ridiculously easy to customize. Need to load an additional object for the :show action? Slap another 
before_filter on it. Need to change the path that the :update action redirects to? Override the :update action with your 
new rendering behavior.

A resource_this generator is included - does the same thing as the 'resource' generator but adds 'resource_this' to the 
generated controller.

Questions? Comments? Flames? Patches?
===========
jnewland@gmail.com

Copyright
===========
Copyright (c) 2007 Jesse Newland, released under the MIT license