added josevalim's inherited resources for RESTful controllers

Dan Croak
1 parent d3a8294d
Showing 35 changed files with 4937 additions and 0 deletions Show diff stats
vendor/gems/josevalim-inherited_resources-0.8.5/.specification
vendor/gems/josevalim-inherited_resources-0.8.5/CHANGELOG
vendor/gems/josevalim-inherited_resources-0.8.5/MIT-LICENSE
vendor/gems/josevalim-inherited_resources-0.8.5/README
vendor/gems/josevalim-inherited_resources-0.8.5/Rakefile
vendor/gems/josevalim-inherited_resources-0.8.5/VERSION
vendor/gems/josevalim-inherited_resources-0.8.5/lib/inherited_resources.rb
vendor/gems/josevalim-inherited_resources-0.8.5/lib/inherited_resources/actions.rb
vendor/gems/josevalim-inherited_resources-0.8.5/lib/inherited_resources/base.rb
vendor/gems/josevalim-inherited_resources-0.8.5/lib/inherited_resources/base_helpers.rb
vendor/gems/josevalim-inherited_resources-0.8.5/lib/inherited_resources/belongs_to_helpers.rb
vendor/gems/josevalim-inherited_resources-0.8.5/lib/inherited_resources/class_methods.rb
vendor/gems/josevalim-inherited_resources-0.8.5/lib/inherited_resources/dumb_responder.rb
vendor/gems/josevalim-inherited_resources-0.8.5/lib/inherited_resources/has_scope_helpers.rb
vendor/gems/josevalim-inherited_resources-0.8.5/lib/inherited_resources/polymorphic_helpers.rb
vendor/gems/josevalim-inherited_resources-0.8.5/lib/inherited_resources/respond_to.rb
vendor/gems/josevalim-inherited_resources-0.8.5/lib/inherited_resources/singleton_helpers.rb
vendor/gems/josevalim-inherited_resources-0.8.5/lib/inherited_resources/url_helpers.rb
vendor/gems/josevalim-inherited_resources-0.8.5/test/aliases_test.rb
vendor/gems/josevalim-inherited_resources-0.8.5/test/base_helpers_test.rb
@@ -0,0 +1,104 @@
+--- !ruby/object:Gem::Specification 
+name: josevalim-inherited_resources
+version: !ruby/object:Gem::Version 
+  version: 0.8.5
+platform: ruby
+authors: 
+- "Jos\xC3\xA9 Valim"
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-07-24 00:00:00 -04:00
+default_executable: 
+dependencies: []
+
+description: Inherited Resources speeds up development by making your controllers inherit all restful actions so you just have to focus on what is important.
+email: jose.valim@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+files: 
+- CHANGELOG
+- MIT-LICENSE
+- README
+- Rakefile
+- VERSION
+- lib/inherited_resources.rb
+- lib/inherited_resources/actions.rb
+- lib/inherited_resources/base.rb
+- lib/inherited_resources/base_helpers.rb
+- lib/inherited_resources/belongs_to_helpers.rb
+- lib/inherited_resources/class_methods.rb
+- lib/inherited_resources/dumb_responder.rb
+- lib/inherited_resources/has_scope_helpers.rb
+- lib/inherited_resources/polymorphic_helpers.rb
+- lib/inherited_resources/respond_to.rb
+- lib/inherited_resources/singleton_helpers.rb
+- lib/inherited_resources/url_helpers.rb
+- test/respond_to_test.rb
+- test/customized_belongs_to_test.rb
+- test/nested_belongs_to_test.rb
+- test/base_test.rb
+- test/redirect_to_test.rb
+- test/has_scope_test.rb
+- test/class_methods_test.rb
+- test/aliases_test.rb
+- test/flash_test.rb
+- test/url_helpers_test.rb
+- test/base_helpers_test.rb
+- test/belongs_to_test.rb
+- test/polymorphic_test.rb
+- test/defaults_test.rb
+- test/singleton_test.rb
+- test/optional_belongs_to_test.rb
+- test/test_helper.rb
+has_rdoc: true
+homepage: http://github.com/josevalim/inherited_resources
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: inherited_resources
+rubygems_version: 1.3.4
+signing_key: 
+specification_version: 3
+summary: Inherited Resources speeds up development by making your controllers inherit all restful actions so you just have to focus on what is important.
+test_files: 
+- test/respond_to_test.rb
+- test/customized_belongs_to_test.rb
+- test/nested_belongs_to_test.rb
+- test/base_test.rb
+- test/redirect_to_test.rb
+- test/has_scope_test.rb
+- test/class_methods_test.rb
+- test/aliases_test.rb
+- test/flash_test.rb
+- test/url_helpers_test.rb
+- test/base_helpers_test.rb
+- test/belongs_to_test.rb
+- test/polymorphic_test.rb
+- test/defaults_test.rb
+- test/singleton_test.rb
+- test/optional_belongs_to_test.rb
+- test/test_helper.rb
@@ -0,0 +1,95 @@
+# Version 0.8
+
+* Fixed a small bug on optional belongs to with namespaced controllers.
+* Allow a parameter to be given to collection_url in polymorphic cases to replace
+  the parent.
+* Allow InheritedResources to be called without inheritance.
+* Ensure that controllers that inherit from a controller with InheritedResources
+  works properly.
+
+# Version 0.7
+
+* Allow procs as default value in has scope to be able to use values from session, for example.
+* Allow blocks with arity 0 or -1 to be given as the redirect url:
+
+    def destroy
+      destroy!{ project_url(@project) }
+    end
+
+* Allow interpolation_options to be set in the application controller.
+* Added has_scope to controller (an interface for named_scopes).
+* Added polymorphic_belongs_to, optional_belongs_to and singleton_belongs_to
+  as quick methods.
+* Only load belongs_to, singleton and polymorphic helpers if they are actually
+  required. base_helpers, class_methods, dumb_responder and url_helpers are loaded
+  when you inherited from base for the first time.
+
+# Version 0.6
+
+* Ensure that the default template is not rendered if the default_template_format
+  is not accepted. This is somehow related with the security breach report:
+
+  http://www.rorsecurity.info/journal/2009/4/24/hidden-actions-render-templates.html
+
+  IR forbids based on mime types. For example: respond_to :html, :except => :index
+  ensures that the index.html.erb view is not rendered, making your IR controllers
+  safer.
+
+* Fixed a bug that happens only when format.xml is given to blocks and then it
+  acts as default, instead of format.html.
+* Fixed a strange bug where when you have create.html.erb or update.html.erb,
+  it makes IE6 and IE7 return unprocessable entity (because they send Mime::ALL).
+* Stop rescueing any error when constantizing the resource class and allow
+  route_prefix to be nil.
+* Cleaned up tests and responder structure. Whenever you pass a block to aliases
+  and this block responds to the request, the other blocks are not parsed improving performance.
+* [BACKWARDS INCOMPATIBLE] By default, Inherited Resources respond only :html requests.
+* Added a quick way to overwrite the redirect to url in :create, :update and :destroy.
+
+# Version 0.5
+
+* Decoupled routes name from :instance_name and :collection_name. This way we
+  have more flexibility. Use route_instance_name and route_collection_name to
+  to change routes.
+* Avoid calling human_name on nil when a resource class is not defined.
+* Only call I18n if it's defined.
+
+# Version 0.4
+
+* Dealing with namespaced controllers out of the box.
+* Added support to namespaced routes through :route_prefix.
+* Added fix when resource_url is not defined.
+* Added better handling for namespaced controllers.
+* Added flash messages scoped by namespaced controllers.
+* Deprecated {{resource}} in I18n, use {{resource_name}} instead.
+* rspec bug fix is not automatically required anymore. User has to do it
+  explicitly.
+* Added a file which fix a rspec bug when render is called inside a method
+  which receives a block.
+* parent? does not take begin_of_association_chain into account anymore
+* Added options to url helpers.
+* Added :optional to belongs_to associations. It allows you to deal with
+  categories/1/products/2 and /products/2 with just one controller.
+* Cleaned up tests.
+
+# Version 0.3
+
+* Minor bump after three bug fixes.
+* Bug fix when showing warning of constant redefinition.
+* Bug fix with ApplicationController not being unloaded properly on development.
+* Bug fix when having root singleton resources. Calling collection_url would
+  raise "NoMethodError _url", not it will call root_url.
+* More comments on UrlHelpers.
+
+# Version 0.2
+
+* Bug fix when ApplicationController is already loaded when we load respond_to.
+* Added support success/failure blocks.
+* Eager loading of files to work properly in multithreaded environments.
+
+# Version 0.1
+
+* Added more helper_methods.
+* Added Rails 2.3.0 and changed tests to work with ActionController::TestCase.
+* First release. Support to I18n, singleton controllers, polymorphic
+controllers, belongs_to, nested_belongs_to and url helpers.
@@ -0,0 +1,20 @@
+Copyright (c) 2009 José Valim
+
+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.
@@ -0,0 +1,517 @@
+Inherited Resources
+License: MIT
+Version: 0.8.5
+
+You can also read this README in pretty html at the GitHub project Wiki page:
+
+  http://wiki.github.com/josevalim/inherited_resources
+
+Description
+-----------
+
+Inherited Resources speeds up development by making your controllers inherit
+all restful actions so you just have to focus on what is important. It makes
+your controllers more powerful and cleaner at the same time.
+
+Plus, making your controllers follow a pattern, it helps you to write better
+code by following fat models and skinny controllers convention.
+
+Inherited Resources is tested and compatible with Rails 2.2.x and Rails 2.3.x.
+
+keywords: resources, controller, singleton, belongs_to, polymorphic, named_scope and I18n
+
+Installation
+------------
+
+Install Inherited Resources is very easy. It is stored in GitHub, so just run
+the following:
+
+   gem sources -a http://gems.github.com
+   sudo gem install josevalim-inherited_resources
+
+If you want it as plugin, just do:
+
+   script/plugin install git://github.com/josevalim/inherited_resources.git
+
+rspec-rails <= 1.1.12 known bug
+-------------------------------
+
+InheritedResources has a known bug with rspec-rails. Please upgrade your rspec
+version or use the fix which ships with InheritedResources:
+
+  require 'inherited_resources/spec'
+
+Basic Usage
+-----------
+
+To use Inherited Resources you just have to inherit (duh) it:
+
+   class ProjectsController < InheritedResources::Base
+   end
+
+And all actions are defined and working, check it! Your projects collection
+(in the index action) is still available in the instance variable @projects
+and your project resource (all other actions) is available as @ project.
+
+The next step is to define which mime types this controller provides:
+
+   class ProjectsController < InheritedResources::Base
+     respond_to :html, :xml, :json
+   end
+
+You can also specify them based per action:
+
+   class ProjectsController < InheritedResources::Base
+     respond_to :html, :xml, :json
+     respond_to :js, :only => :create
+     respond_to :iphone, :except => [ :edit, :update ]
+   end
+
+For each request, it first checkes if the "controller/action.format" file is
+available (for example "projects/create.xml") and if it's not, it checks if
+the resource respond to :to_format (in this case, :to_xml). Otherwise returns 404.
+
+Another option is to specify which actions the controller will inherit from
+the InheritedResources::Base:
+
+   class ProjectsController < InheritedResources::Base
+     actions :index, :show, :new, :create
+   end
+
+Or:
+
+   class ProjectsController < InheritedResources::Base
+     actions :all, :except => [ :edit, :update, :destroy ]
+   end
+
+In your views, you will get the following helpers:
+
+   resource        #=> @project
+   collection      #=> @projects
+   resource_class  #=> Project
+
+As you might expect, collection (@projects instance variable) is only available
+on index actions.
+
+If for some reason you cannot inherit from InheritedResources::Base, you can
+call inherit_resources or resource_controller in your controller class scope:
+
+  class AccountsController < ApplicationController
+    inherit_resources # or resource_controller
+  end
+
+Overwriting defaults
+--------------------
+
+Whenever you inherit from InheritedResources, several defaults are assumed.
+For example you can have an AccountsController to account management while the
+resource is an User:
+
+   class AccountsController < InheritedResources::Base
+     defaults :resource_class => User, :collection_name, 'users', :instance_name => 'user'
+   end
+
+In the case above, in your views you will have @users and @user variables, but
+the routes used will still be accounts_url and account_url. If you plan also to
+change the routes, you can use :route_collection_name and :route_instance_name.
+
+Namespaced controllers work out of the box, but if you need to specify a
+different route prefix, you can do the following:
+
+   class Administrators::PeopleController < InheritedResources::Base
+     defaults :route_prefix => 'admin'
+   end
+
+Then your named routes will be: 'admin_people_url', 'admin_person_url' instead
+of 'administrators_people_url' and 'administrators_person_url'.
+
+If you want to customize how resources are retrieved you can overwrite
+collection and resource methods. The first is called on index action and the
+second on all other actions. Let's suppose you want to add pagination to your
+projects collection:
+
+   class ProjectsController < InheritedResources::Base
+     protected
+       def collection
+         @projects ||= end_of_association_chain.paginate(params[:page]).all
+       end
+   end
+
+The end_of_association_chain returns your resource after nesting all associations
+and scopes (more about this below).
+
+InheritedResources also introduces another method called begin_of_association_chain.
+It's mostly used when you want to create resources based on the @current_user and
+you have urls like "account/projects". In such cases, you have to do
+@current_user.projects.find or @current_user.projects.build in your actions.
+
+You can deal with it just doing:
+
+   class ProjectsController < InheritedResources::Base
+     protected
+       def begin_of_association_chain
+         @current_user
+       end
+   end
+
+Overwriting actions
+-------------------
+
+Let's suppose that after destroying a project you want to redirect to your
+root url instead of redirecting to projects url. You just have to do:
+
+   class ProjectsController < InheritedResources::Base
+     def destroy
+       super do |format|
+         format.html { redirect_to root_url }
+       end
+     end
+   end
+
+You are opening your action and giving the parent action a new behavior. No
+tricks, no DSL, just Ruby.
+
+On the other hand, I have to agree that calling super is not very readable.
+That's why all methods have aliases. So this is equivalent:
+
+   class ProjectsController < InheritedResources::Base
+     def destroy
+       destroy! do |format|
+         format.html { redirect_to root_url }
+       end
+     end
+   end
+
+Even more, since most of the times when you change a create, update or destroy
+action is because you want to to change to where it redirects, a shortcut is
+provided. So you can do:
+
+   class ProjectsController < InheritedResources::Base
+     def destroy
+       destroy!{ root_url }
+     end
+   end
+
+Now let's suppose that before create a project you have to do something special
+but you don't want to create a before filter for it:
+
+   class ProjectsController < InheritedResources::Base
+     def create
+       @project = Project.new(params[:project])
+       @project.something_special!
+       create!
+     end
+   end
+
+Yes, that simple! The nice part is since you already set the instance variable
+@project, it will not build a project again.
+
+Before we finish this topic, we should talk about one more thing: "success/failure
+blocks". Let's suppose that when we update our project, in case of failure, we
+want to redirect to the project url instead of re-rendering the edit template.
+
+Our first attempt to do this would be:
+
+   class ProjectsController < InheritedResources::Base
+     def update
+       update! do |format|
+         unless @project.errors.empty? # failure
+           format.html { redirect_to project_url(@project) }
+         end
+       end
+     end
+   end
+
+Looks to verbose, right? We can actually do:
+
+   class ProjectsController < InheritedResources::Base
+     def update
+       update! do |success, failure|
+         failure.html { redirect_to project_url(@project) }
+       end
+     end
+   end
+
+Much better! So explaining everything: when you give a block which expects one
+argument it will be executed in both scenarios: success and failure. But If you
+give a block that expects two arguments, the first will be executed only in
+success scenarios and the second in failure scenarios. You keep everything
+clean and organized inside the same action.
+
+Flash messages and I18n
+-----------------------
+
+Flash messages are powered by I18n api. It checks for messages in the following
+order:
+
+   flash.controller_name.action_name.status
+   flash.actions.action_name.status
+
+If none is available, a default message in english set. In a create action
+on projects controller, it will search for:
+
+   flash.projects.create.status
+   flash.actions.create.status
+
+The status can be :notice (when the object can be created, updated
+or destroyed with success) or :error (when the objecy cannot be created
+or updated).
+
+Those messages are interpolated by using the resource class human name, which 
+is also localized and it means you can set:
+
+   flash:
+     actions:
+       create:
+         notice: "Hooray! {{resource_name}} was successfully created!"
+
+It will replace {{resource_name}} by the human name of the resource class,
+which is "Project" in this case.
+
+But sometimes, flash messages are not that simple. Sometimes you want to say
+the title of the project while updating a project. Well, that's easy also:
+
+   flash:
+     projects:
+       update:
+         notice: "Hooray! The project "{{project_title}}" was updated!"
+
+Since :project_title is not available for interpolation by default, you have
+to overwrite interpolation_options.
+
+   def interpolation_options
+     { :project_title => @project.title }
+   end
+
+Then you will finally have:
+
+   "Hooray! The project "Plataforma" was updated!"
+
+By default, resource name is capitalized. If you want to make it lower case, you
+can add to your application controller:
+
+   def interpolation_options
+     { :resource_name => resource_class.human_name.downcase }
+  end
+
+Finally, if your controller is namespaced, for example Admin::ProjectsController,
+the messages will be checked in the following order:
+
+   flash.admin.projects.create.notice
+   flash.admin.actions.create.notice
+   flash.projects.create.notice
+   flash.actions.create.notice
+
+Has Scope
+---------
+
+InheritedResources tries to integrate nicely with your model. In order to do so,
+it also is named_scope fluent. Let's suppose our Project model with the scopes:
+
+  class ProjectsController < ActiveRecord::Base
+    named_scope :featured, :conditions => { :featured => true }
+    named_scope :by_methodology, proc {|methodology| { :conditions => { :methodology => methodology } } }
+    named_scope :limit, proc{|limit| :limit => limit.to_i }
+  end
+
+Your controller:
+
+  class ProjectsController < InheritedResources::Base
+    has_scope :featured, :boolean => true, :only => :index
+    has_scope :by_methodology
+    has_scope :limit, :default => 10
+  end
+
+Then for each request:
+
+  /projects
+  #=> acts like a normal request, but returning 10 projects
+
+  /projects?featured=true
+  #=> calls the featured named scope and bring 10 featured projects
+
+  /projects?featured=true&by_methodology=agile&limit=20
+  #=> brings 20 featured projects with methodology agile
+
+You can retrieve the current scopes in use with :current_scopes method.
+In the last case, it would return:
+
+  { :featured => "true", :by_methodology => "agile", :limit => "20" }
+
+Finally, let's suppose you store on the session how many projects the user sees
+per page. In such cases, you can give a proc as default value:
+
+   has_scope :limit, :default => proc{|c| c.session[:limit] || 10 }
+
+Belongs to
+----------
+
+Finally, our Projects are going to get some Tasks. Then you create a
+TasksController and do:
+
+   class TasksController < InheritedResources::Base
+     belongs_to :project
+   end
+
+belongs_to accepts several options to be able to configure the association.
+For example, if you want urls like /projects/:project_title/tasks, you can
+customize how InheritedResources find your projects:
+
+   class TasksController < InheritedResources::Base
+     belongs_to :project, :finder => :find_by_title!, :param => :project_title
+   end
+
+It also accepts :route_name, :parent_class and :instance_name as options.
+Check the lib/inherited_resources/class_methods.rb for more.
+
+Nested belongs to
+-----------------
+
+Now, our Tasks get some Comments and you need to nest even deeper. Good
+practices says that you should never nest more than two resources, but sometimes
+you have to for security reasons. So this is an example of how you can do it:
+
+   class CommentsController < InheritedResources::Base
+     nested_belongs_to :project, :task
+   end
+
+If you need to configure any of these belongs to, you can nested them using blocks:
+
+   class CommentsController < InheritedResources::Base
+     belongs_to :project, :finder => :find_by_title!, :param => :project_title do
+       belongs_to :task
+     end
+   end
+
+Warning: calling several belongs_to is the same as nesting them:
+
+   class CommentsConroller < InheritedResources::Base
+     belongs_to :project
+     belongs_to :task
+   end
+
+In other words, the code above is the same as calling nested_belongs_to.
+
+Polymorphic belongs to
+----------------------
+
+We can go even further. Let's suppose our Projects can now have Files, Messages
+and Tasks, and they are all commentable. In this case, the best solution is to
+use polymorphism:
+
+   class CommentsController < InheritedResources::Base
+     belongs_to :task, :file, :message, :polymorphic => true
+     # polymorphic_belongs_to :task, :file, :message
+   end
+
+You can even use it with nested resources:
+
+   class CommentsController < InheritedResources::Base
+     belongs_to :project do
+       belongs_to :task, :file, :message, :polymorphic => true
+     end
+   end
+
+The url in such cases can be:
+
+   /project/1/task/13/comments
+   /project/1/file/11/comments
+   /project/1/message/9/comments
+
+When using polymorphic associations, you get some free helpers:
+
+   parent?         #=> true
+   parent_type     #=> :task
+   parent_class    #=> Task
+   parent          #=> @task
+
+Optional belongs to
+-------------------
+
+Later you decide to create a view to show all comments, independent if they belong
+to a task, file or message. You can reuse your polymorphic controller just doing:
+
+  class ProjectsController < InheritedResources::Base
+    belongs_to :task, :file, :message, :optional => true
+    # optional_belongs_to :task, :file, :message
+  end
+
+This will handle all those urls properly:
+
+  /comment/1
+  /tasks/2/comment/5
+  /files/10/comment/3
+  /messages/13/comment/11
+
+This is treated as a special type of polymorphic associations, thus all helpers
+are available. As you expect, when no parent is found, the helpers return:
+
+   parent?         #=> false
+   parent_type     #=> nil
+   parent_class    #=> nil
+   parent          #=> nil
+
+Singletons
+----------
+
+Now we are going to add manager to projects. We say that Manager is a singleton
+resource because a Project has just one manager. You should declare it as
+has_one (or resource) in your routes.
+
+To declare an association as singleton, you just have to give the :singleton
+option.
+
+   class ManagersController < InheritedResources::Base
+     belongs_to :project, :singleton => true
+     # singleton_belongs_to :project
+   end
+
+It will deal with everything again and hide the action :index from you.
+
+URL Helpers
+-----------
+
+When you use InheritedResources it creates some URL helpers.
+And they handle everything for you. :)
+
+   # /posts/1/comments
+   resource_url               # => /posts/1/comments/#{@comment.to_param}
+   resource_url(comment)      # => /posts/1/comments/#{comment.to_param}
+   new_resource_url           # => /posts/1/comments/new
+   edit_resource_url          # => /posts/1/comments/#{@comment.to_param}/edit
+   edit_resource_url(comment) #=>  /posts/1/comments/#{comment.to_param}/edit
+   collection_url             # => /posts/1/comments
+
+   # /projects/1/tasks
+   resource_url               # => /projects/1/tasks/#{@task.to_param}
+   resource_url(task)         # => /projects/1/tasks/#{task.to_param}
+   new_resource_url           # => /projects/1/tasks/new
+   edit_resource_url          # => /projects/1/tasks/#{@task.to_param}/edit
+   edit_resource_url(task)    # => /projects/1/tasks/#{task.to_param}/edit
+   collection_url             # => /projects/1/tasks
+
+   # /users
+   resource_url               # => /users/#{@user.to_param}
+   resource_url(user)         # => /users/#{user.to_param}
+   new_resource_url           # => /users/new
+   edit_resource_url          # => /users/#{@user.to_param}/edit
+   edit_resource_url(user)    # => /users/#{user.to_param}/edit
+   collection_url             # => /users
+
+Those urls helpers also accepts a hash as options, just as in named routes.
+
+   # /projects/1/tasks
+   collection_url(:page => 1, :limit => 10) #=> /projects/1/tasks?page=1&limit=10
+
+Another nice thing is that those urls are not guessed during runtime. They are
+all created when your application is loaded (except for polymorphic
+associations, that relies on Rails polymorphic_url).
+
+Bugs and Feedback
+-----------------
+
+If you discover any bugs, please send an e-mail to jose.valim@gmail.com
+If you just want to give some positive feedback or drop a line, that's fine too!
+
+Copyright (c) 2009 José Valim
+http://josevalim.blogspot.com/
@@ -0,0 +1,35 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |s|
+    s.name = "inherited_resources"
+    s.rubyforge_project = "inherited_resources"
+    s.summary = "Inherited Resources speeds up development by making your controllers inherit all restful actions so you just have to focus on what is important."
+    s.email = "jose.valim@gmail.com"
+    s.homepage = "http://github.com/josevalim/inherited_resources"
+    s.description = "Inherited Resources speeds up development by making your controllers inherit all restful actions so you just have to focus on what is important."
+    s.authors = ['José Valim']
+    s.files =  FileList["[A-Z]*", "{lib}/**/*"]
+  end
+rescue LoadError
+  puts "Jeweler, or one of its dependencies, is not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+end
+
+desc 'Run tests for InheritedResources.'
+Rake::TestTask.new(:test) do |t|
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end
+
+desc 'Generate documentation for InheritedResources.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'InheritedResources'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README')
+  rdoc.rdoc_files.include('MIT-LICENSE')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
@@ -0,0 +1 @@
+0.8.5
@@ -0,0 +1,18 @@
+# respond_to is the only file that should be loaded before hand. All others
+# are loaded on demand.
+#
+require File.join(File.dirname(__FILE__), 'inherited_resources', 'respond_to')
+
+module InheritedResources; end
+
+class ActionController::Base
+  # If you cannot inherit from InheritedResources::Base you can call
+  # inherit_resource in your controller to have all the required modules and
+  # funcionality included.
+  #
+  def self.inherit_resources
+    InheritedResources::Base.inherit_resources(self)
+    initialize_resources_class_accessors!
+    create_resources_url_helpers!
+  end
+end
@@ -0,0 +1,96 @@
+module InheritedResources
+  RESOURCES_ACTIONS = [ :index, :show, :new, :edit, :create, :update, :destroy ] unless self.const_defined?(:RESOURCES_ACTIONS)
+
+  # Holds all default actions for InheritedResouces.
+  module Actions
+
+    # GET /resources
+    def index(&block)
+      respond_to(:with => collection, &block)
+    end
+    alias :index! :index
+
+    # GET /resources/1
+    def show(&block)
+      respond_to(:with => resource, &block)
+    end
+    alias :show! :show
+
+    # GET /resources/new
+    def new(&block)
+      respond_to(:with => build_resource, &block)
+    end
+    alias :new! :new
+
+    # GET /resources/1/edit
+    def edit(&block)
+      respond_to(:with => resource, &block)
+    end
+    alias :edit! :edit
+
+    # POST /resources
+    def create(&block)
+      object = build_resource
+      respond_block, redirect_block = select_block_by_arity(block)
+
+      if object.save
+        set_flash_message!(:notice, '{{resource_name}} was successfully created.')
+        options = { :with => object, :status => :created, :location => (resource_url rescue nil) }
+
+        respond_to_with_dual_blocks(true, respond_block, options) do |format|
+          format.html { redirect_to(redirect_block ? redirect_block.call : resource_url) }
+        end
+      else
+        set_flash_message!(:error)
+        options = { :with => object.errors, :status => :unprocessable_entity }
+
+        respond_to_with_dual_blocks(false, respond_block, options) do |format|
+          format.html { render :action => 'new' }
+        end
+      end
+    end
+    alias :create! :create
+
+    # PUT /resources/1
+    def update(&block)
+      object = resource
+      respond_block, redirect_block = select_block_by_arity(block)
+
+      if object.update_attributes(params[resource_instance_name])
+        set_flash_message!(:notice, '{{resource_name}} was successfully updated.')
+
+        respond_to_with_dual_blocks(true, block) do |format|
+          format.html { redirect_to(redirect_block ? redirect_block.call : resource_url) }
+          format.all  { head :ok }
+        end
+      else
+        set_flash_message!(:error)
+
+        options = { :with => object.errors, :status => :unprocessable_entity }
+
+        respond_to_with_dual_blocks(false, block, options) do |format|
+          format.html { render :action => 'edit' }
+        end
+      end
+    end
+    alias :update! :update
+
+    # DELETE /resources/1
+    def destroy(&block)
+      resource.destroy
+      respond_block, redirect_block = select_block_by_arity(block)
+
+      set_flash_message!(:notice, '{{resource_name}} was successfully destroyed.')
+
+      respond_to_with_dual_blocks(nil, respond_block) do |format|
+        format.html { redirect_to(redirect_block ? redirect_block.call : collection_url) }
+        format.all  { head :ok }
+      end
+    end
+    alias :destroy! :destroy
+
+    # Make aliases protected
+    protected :index!, :show!, :new!, :create!, :edit!, :update!, :destroy!
+
+  end
+end
@@ -0,0 +1,39 @@
+module InheritedResources
+  # = Base
+  #
+  # This is the base class that holds all actions. If you see the code for each
+  # action, they are quite similar to Rails default scaffold.
+  #
+  # To change your base behavior, you can overwrite your actions and call super,
+  # call <tt>default</tt> class method, call <<tt>actions</tt> class method
+  # or overwrite some helpers in the base_helpers.rb file.
+  #
+  class Base < ::ApplicationController
+    unloadable
+
+    # Overwrite inherit_resources to add specific InheritedResources behavior.
+    #
+    def self.inherit_resources(base)
+      base.class_eval do
+        include InheritedResources::Actions
+        include InheritedResources::BaseHelpers
+        extend  InheritedResources::ClassMethods
+        extend  InheritedResources::UrlHelpers
+
+        helper_method :collection_url, :collection_path, :resource_url, :resource_path,
+                      :new_resource_url, :new_resource_path, :edit_resource_url, :edit_resource_path,
+                      :resource, :collection, :resource_class
+
+        base.with_options :instance_writer => false do |c|
+          c.class_inheritable_accessor :resource_class
+          c.class_inheritable_array :parents_symbols
+          c.class_inheritable_hash :resources_configuration, :scopes_configuration
+        end
+
+        protected :resource_class, :parents_symbols, :resources_configuration, :scopes_configuration
+      end
+    end
+
+    inherit_resources(self)
+  end
+end
@@ -0,0 +1,329 @@
+# Whenever base is required load the dumb responder since it's used inside actions.
+require File.dirname(__FILE__) + '/dumb_responder.rb'
+
+module InheritedResources
+  # Base helpers for InheritedResource work. Some methods here can be overwriten
+  # and you will need to do that to customize your controllers from time to time.
+  #
+  module BaseHelpers
+
+    protected
+
+      # This is how the collection is loaded.
+      #
+      # You might want to overwrite this method if you want to add pagination
+      # for example. When you do that, don't forget to cache the result in an
+      # instance_variable:
+      #
+      #   def collection
+      #     @projects ||= end_of_association_chain.paginate(params[:page]).all
+      #   end
+      #
+      def collection
+        get_collection_ivar || set_collection_ivar(end_of_association_chain.find(:all))
+      end
+
+      # This is how the resource is loaded.
+      #
+      # You might want to overwrite this method when you are using permalink.
+      # When you do that, don't forget to cache the result in an
+      # instance_variable:
+      #
+      #   def resource
+      #     @project ||= end_of_association_chain.find_by_permalink!(params[:id])
+      #   end
+      #
+      # You also might want to add the exclamation mark at the end of the method
+      # because it will raise a 404 if nothing can be found. Otherwise it will
+      # probably render a 500 error message.
+      #
+      def resource
+        get_resource_ivar || set_resource_ivar(end_of_association_chain.find(params[:id]))
+      end
+
+      # This method is responsable for building the object on :new and :create
+      # methods. If you overwrite it, don't forget to cache the result in an
+      # instance variable.
+      #
+      def build_resource
+        get_resource_ivar || set_resource_ivar(end_of_association_chain.send(method_for_build, params[resource_instance_name]))
+      end
+
+      # This class allows you to set a instance variable to begin your
+      # association chain. For example, usually your projects belongs to users
+      # and that means that they belong to the current logged in user. So you
+      # could do this:
+      #
+      #   def begin_of_association_chain
+      #     @current_user
+      #   end
+      #
+      # So every time we instantiate a project, we will do:
+      #
+      #   @current_user.projects.build(params[:project])
+      #   @current_user.projects.find(params[:id])
+      #
+      # The variable set in begin_of_association_chain is not sent when building
+      # urls, so this is never going to happen when calling resource_url:
+      #
+      #   project_url(@current_user, @project)
+      #
+      # If the user actually scopes the url, you should use belongs_to method
+      # and declare that projects belong to user.
+      #
+      def begin_of_association_chain
+        nil
+      end
+
+      # Returns if the controller has a parent. When only base helpers are loaded,
+      # it's always false and should not be overwriten.
+      #
+      def parent?
+        false
+      end
+
+      # Overwrite this method to provide other interpolation options when
+      # the flash message is going to be set.
+      #
+      # def interpolation_options
+      #    { }
+      # end
+
+    private
+
+      # Fast accessor to resource_collection_name
+      #
+      def resource_collection_name #:nodoc:
+        self.resources_configuration[:self][:collection_name]
+      end
+
+      # Fast accessor to resource_instance_name
+      #
+      def resource_instance_name #:nodoc:
+        self.resources_configuration[:self][:instance_name]
+      end
+
+      # This methods gets your begin_of_association_chain, join it with your
+      # parents chain and returns the scoped association.
+      #
+      def end_of_association_chain #:nodoc:
+        chain = symbols_for_association_chain.inject(begin_of_association_chain) do |chain, symbol|
+          evaluate_parent(symbol, resources_configuration[symbol], chain)
+        end
+
+        if chain
+          if method_for_association_chain
+            apply_scope_to(chain.send(method_for_association_chain))
+          else
+            # This only happens when we specify begin_of_association_chain in
+            # a singletion controller without parents. In this case, the chain
+            # is exactly the begin_of_association_chain which is already an
+            # instance and then not scopable.
+            chain
+          end
+        else
+          apply_scope_to(resource_class)
+        end
+      end
+
+      # Returns the appropriated method to build the resource.
+      #
+      def method_for_build #:nodoc:
+        (begin_of_association_chain || parent?) ? method_for_association_build : :new
+      end
+
+      # Returns the name of the method used for build the resource in cases
+      # where we have a parent. This is overwritten in singleton scenarios.
+      #
+      def method_for_association_build
+        :build
+      end
+
+      # Returns the name of the method to be called, before returning the end
+      # of the association chain. This is overwriten by singleton cases
+      # where no method for association chain is called.
+      #
+      def method_for_association_chain #:nodoc:
+        resource_collection_name
+      end
+
+      # Get resource ivar based on the current resource controller.
+      #
+      def get_resource_ivar #:nodoc:
+        instance_variable_get("@#{resource_instance_name}")
+      end
+
+      # Set resource ivar based on the current resource controller.
+      #
+      def set_resource_ivar(resource) #:nodoc:
+        instance_variable_set("@#{resource_instance_name}", resource)
+      end
+
+      # Get collection ivar based on the current resource controller.
+      #
+      def get_collection_ivar #:nodoc:
+        instance_variable_get("@#{resource_collection_name}")
+      end
+
+      # Set collection ivar based on the current resource controller.
+      #
+      def set_collection_ivar(collection) #:nodoc:
+        instance_variable_set("@#{resource_collection_name}", collection)
+      end
+
+      # Helper to set flash messages. It's powered by I18n API.
+      # It checks for messages in the following order:
+      #
+      #   flash.controller_name.action_name.status
+      #   flash.actions.action_name.status
+      #
+      # If none is available, a default message is set. So, if you have
+      # a CarsController, create action, it will check for:
+      #
+      #   flash.cars.create.status
+      #   flash.actions.create.status
+      #
+      # The statuses can be :notice (when the object can be created, updated
+      # or destroyed with success) or :error (when the objecy cannot be created
+      # or updated).
+      #
+      # Those messages are interpolated by using the resource class human name.
+      # This means you can set:
+      #
+      #   flash:
+      #     actions:
+      #       create:
+      #         notice: "Hooray! {{resource_name}} was successfully created!"
+      #
+      # But sometimes, flash messages are not that simple. Going back
+      # to cars example, you might want to say the brand of the car when it's
+      # updated. Well, that's easy also:
+      #
+      #   flash:
+      #     cars:
+      #       update:
+      #         notice: "Hooray! You just tuned your {{car_brand}}!"
+      #
+      # Since :car_name is not available for interpolation by default, you have
+      # to overwrite interpolation_options.
+      #
+      #   def interpolation_options
+      #     { :car_brand => @car.brand }
+      #   end
+      #
+      # Then you will finally have:
+      #
+      #   'Hooray! You just tuned your Aston Martin!'
+      #
+      # If your controller is namespaced, for example Admin::CarsController,
+      # the messages will be checked in the following order:
+      #
+      #   flash.admin.cars.create.status
+      #   flash.admin.actions.create.status
+      #   flash.cars.create.status
+      #   flash.actions.create.status
+      #
+      def set_flash_message!(status, default_message=nil)
+        return flash[status] = default_message unless defined?(::I18n)
+
+        resource_name = if resource_class
+          if resource_class.respond_to?(:human_name)
+            resource_class.human_name
+          else
+            resource_class.name.humanize
+          end
+        else
+          "Resource"
+        end
+
+        given_options = if self.respond_to?(:interpolation_options)
+          interpolation_options
+        else
+          {}
+        end
+
+        options = {
+          :default  => default_message || '',
+          :resource_name => resource_name
+        }.merge(given_options)
+
+        defaults = []
+        slices   = controller_path.split('/')
+
+        while slices.size > 0
+          defaults << :"flash.#{slices.fill(controller_name, -1).join('.')}.#{action_name}.#{status}"
+          defaults << :"flash.#{slices.fill(:actions, -1).join('.')}.#{action_name}.#{status}"
+          slices.shift
+        end
+
+        options[:default] = defaults.push(options[:default])
+        options[:default].flatten!
+
+        message = ::I18n.t options[:default].shift, options
+        flash[status] = message unless message.blank?
+      end
+
+      # Used to allow to specify success and failure within just one block:
+      #
+      #   def create
+      #     create! do |success, failure|
+      #       failure.html { redirect_to root_url }
+      #     end
+      #   end
+      #
+      def respond_to_with_dual_blocks(success, dual_block, options={}, &block) #:nodoc:
+        responder = ActionController::MimeResponds::Responder.new(self)
+
+        if dual_block
+          if dual_block.arity == 2
+            dumb_responder = InheritedResources::DumbResponder.new
+            if success
+              dual_block.call(responder, dumb_responder)
+            else
+              dual_block.call(dumb_responder, responder)
+            end
+          else
+            dual_block.call(responder)
+          end
+
+          # Try to respond with the block given
+          responder.respond_except_any
+        end
+
+        respond_to(options.merge!(:responder => responder, :prioritize => :html), &block) unless performed?
+      end
+
+      # Hook to apply scopes. By default returns only the target_object given.
+      # It's extend by HasScopeHelpers.
+      #
+      def apply_scope_to(target_object) #:nodoc:
+        target_object
+      end
+
+      # Symbols chain in base helpers return nothing. This is later overwriten
+      # by belongs_to and can be complex in polymorphic cases.
+      #
+      def symbols_for_association_chain #:nodoc:
+        []
+      end
+
+      # Holds InheritedResources block structure. It returns two blocks: the first
+      # is used in respond_to blocks and the second is the redirect_to url.
+      #
+      def select_block_by_arity(block) #:nodoc
+        if block
+          case block.arity
+            when 2, 1
+              [block, nil]
+            when 0, -1
+              [nil, block]
+            else
+              raise ScriptError, "InheritedResources does not know how to handle blocks with arity #{block.arity}"
+          end
+        else
+          [nil, nil]
+        end
+      end
+
+  end
+end
@@ -0,0 +1,89 @@
+module InheritedResources
+
+  # = belongs_to
+  #
+  # Let's suppose that we have some tasks that belongs to projects. To specify
+  # this assoication in your controllers, just do:
+  #
+  #    class TasksController < InheritedResources::Base
+  #      belongs_to :project
+  #    end
+  #
+  # belongs_to accepts several options to be able to configure the association.
+  # For example, if you want urls like /projects/:project_title/tasks, you
+  # can customize how InheritedResources find your projects:
+  #
+  #    class TasksController < InheritedResources::Base
+  #      belongs_to :project, :finder => :find_by_title!, :param => :project_title
+  #    end
+  #
+  # It also accepts :route_name, :parent_class and :instance_name as options.
+  # Check the lib/inherited_resources/class_methods.rb for more.
+  #
+  # = nested_belongs_to
+  #
+  # Now, our Tasks get some Comments and you need to nest even deeper. Good
+  # practices says that you should never nest more than two resources, but sometimes
+  # you have to for security reasons. So this is an example of how you can do it:
+  #
+  #    class CommentsController < InheritedResources::Base
+  #      nested_belongs_to :project, :task
+  #    end
+  #
+  # If you need to configure any of these belongs to, you can nested them using blocks:
+  #
+  #    class CommentsController < InheritedResources::Base
+  #      belongs_to :project, :finder => :find_by_title!, :param => :project_title do
+  #        belongs_to :task
+  #      end
+  #    end
+  #
+  # Warning: calling several belongs_to is the same as nesting them:
+  #
+  #    class CommentsController < InheritedResources::Base
+  #      belongs_to :project
+  #      belongs_to :task
+  #    end
+  #
+  # In other words, the code above is the same as calling nested_belongs_to.
+  #
+  module BelongsToHelpers
+
+    protected
+
+      # Parent is always true when belongs_to is called.
+      #
+      def parent?
+        true
+      end
+
+    private
+
+      # Evaluate the parent given. This is used to nest parents in the
+      # association chain.
+      #
+      def evaluate_parent(parent_symbol, parent_config, chain = nil) #:nodoc:
+        instantiated_object = instance_variable_get("@#{parent_config[:instance_name]}")
+        return instantiated_object if instantiated_object
+
+        parent = if chain
+          chain.send(parent_config[:collection_name])
+        else
+          parent_config[:parent_class]
+        end
+
+        parent = parent.send(parent_config[:finder], params[parent_config[:param]])
+
+        instance_variable_set("@#{parent_config[:instance_name]}", parent)
+      end
+
+      # Maps parents_symbols to build association chain. In this case, it
+      # simply return the parent_symbols, however on polymorphic belongs to,
+      # it has some customization.
+      #
+      def symbols_for_association_chain #:nodoc:
+        parents_symbols
+      end
+
+  end
+end
@@ -0,0 +1,328 @@
+module InheritedResources
+  module ClassMethods
+
+    protected
+
+      # Used to overwrite the default assumptions InheritedResources do. Whenever
+      # this method is called, it should be on the top of your controller, since
+      # almost other methods depends on the values given to <<tt>>defaults</tt>.
+      #
+      # == Options
+      #
+      # * <tt>:resource_class</tt> - The resource class which by default is guessed
+      #                              by the controller name. Defaults to Project in
+      #                              ProjectsController.
+      #
+      # * <tt>:collection_name</tt> - The name of the collection instance variable which
+      #                               is set on the index action. Defaults to :projects in
+      #                               ProjectsController.
+      #
+      # * <tt>:instance_name</tt> - The name of the singular instance variable which
+      #                             is set on all actions besides index action. Defaults to
+      #                             :project in ProjectsController.
+      #
+      # * <tt>:route_collection_name</tt> - The name of the collection route. Defaults to :collection_name.
+      #
+      # * <tt>:route_instance_name</tt> - The name of the singular route. Defaults to :instance_name.
+      #
+      # * <tt>:route_prefix</tt> - The route prefix which is automically set in namespaced
+      #                            controllers. Default to :admin on Admin::ProjectsController.
+      #
+      # * <tt>:singleton</tt> - Tells if this controller is singleton or not.
+      #
+      def defaults(options)
+        raise ArgumentError, 'Class method :defaults expects a hash of options.' unless options.is_a? Hash
+
+        options.symbolize_keys!
+        options.assert_valid_keys(:resource_class, :collection_name, :instance_name,
+                                  :class_name, :route_prefix, :route_collection_name,
+                                  :route_instance_name, :singleton)
+
+        self.resource_class = options.delete(:resource_class)         if options.key?(:resource_class)
+        self.resource_class = options.delete(:class_name).constantize if options.key?(:class_name)
+
+        acts_as_singleton! if options.delete(:singleton)
+
+        config = self.resources_configuration[:self]
+        config[:route_prefix] = options.delete(:route_prefix) if options.key?(:route_prefix)
+
+        options.each do |key, value|
+          config[key] = value.to_sym
+        end
+
+        create_resources_url_helpers!
+      end
+
+      # Defines wich actions to keep from the inherited controller.
+      # Syntax is borrowed from resource_controller.
+      #
+      #   actions :index, :show, :edit
+      #   actions :all, :except => :index
+      #
+      def actions(*actions_to_keep)
+        raise ArgumentError, 'Wrong number of arguments. You have to provide which actions you want to keep.' if actions_to_keep.empty?
+
+        options = actions_to_keep.extract_options!
+        actions_to_keep.map!{ |a| a.to_s }
+
+        actions_to_remove = Array(options[:except])
+        actions_to_remove.map!{ |a| a.to_s }
+
+        actions_to_remove += RESOURCES_ACTIONS.map{|a| a.to_s } - actions_to_keep unless actions_to_keep.first == 'all'
+        actions_to_remove.uniq!
+
+        (instance_methods & actions_to_remove).each do |action|
+          undef_method action, "#{action}!"
+        end
+      end
+
+      # Detects params from url and apply as scopes to your classes.
+      #
+      # Your model:
+      #
+      #   class Graduation < ActiveRecord::Base
+      #     named_scope :featured, :conditions => { :featured => true }
+      #     named_scope :by_degree, proc {|degree| { :conditions => { :degree => degree } } }
+      #   end
+      #
+      # Your controller:
+      #
+      #   class GraduationsController < InheritedResources::Base
+      #     has_scope :featured, :boolean => true, :only => :index
+      #     has_scope :by_degree, :only => :index
+      #   end
+      #
+      # Then for each request:
+      #
+      #   /graduations
+      #   #=> acts like a normal request
+      #
+      #   /graduations?featured=true
+      #   #=> calls the named scope and bring featured graduations
+      #
+      #   /graduations?featured=true&by_degree=phd
+      #   #=> brings featured graduations with phd degree
+      #
+      # You can retrieve the current scopes in use with <tt>current_scopes</tt>
+      # method. In the last case, it would return: { :featured => "true", :by_degree => "phd" }
+      #
+      # == Options
+      #
+      # * <tt>:boolean</tt> - When set to true, call the scope only when the params is true or 1,
+      #                       and does not send the value as argument.
+      #
+      # * <tt>:only</tt> - In each actions the scope is applied. By default is :all.
+      #
+      # * <tt>:except</tt> - In each actions the scope is not applied. By default is :none.
+      #
+      # * <tt>:key</tt> - The key in the params hash expected to find the scope.
+      #                   Defaults to the scope name.
+      #
+      # * <tt>:default</tt> - Default value for the scope. Whenever supplied the scope
+      #                       is always called. This is useful to add easy pagination!
+      #
+      def has_scope(*scopes)
+        options = scopes.extract_options!
+
+        options.symbolize_keys!
+        options.assert_valid_keys(:boolean, :key, :only, :except, :default)
+
+        if self.scopes_configuration.empty?
+          include HasScopeHelpers
+          helper_method :current_scopes
+        end
+
+        scopes.each do |scope|
+          self.scopes_configuration[scope]         ||= {}
+          self.scopes_configuration[scope][:key]     = options[:key] || scope
+          self.scopes_configuration[scope][:only]    = Array(options[:only])
+          self.scopes_configuration[scope][:except]  = Array(options[:except])
+          self.scopes_configuration[scope][:boolean] = options[:boolean] if options.key?(:boolean)
+          self.scopes_configuration[scope][:default] = options[:default] if options.key?(:default)
+        end
+      end
+
+      # Defines that this controller belongs to another resource.
+      #
+      #   belongs_to :projects
+      #
+      # == Options
+      #
+      # * <tt>:parent_class</tt> - Allows you to specify what is the parent class.
+      #
+      #     belongs_to :project, :parent_class => AdminProject
+      #
+      # * <tt>:class_name</tt> - Also allows you to specify the parent class, but you should
+      #                          give a string. Added for ActiveRecord belongs to compatibility.
+      #
+      # * <tt>:instance_name</tt> - The instance variable name. By default is the name of the association.
+      #
+      #     belongs_to :project, :instance_name => :my_project
+      #
+      # * <tt>:finder</tt> - Specifies which method should be called to instantiate the parent.
+      #
+      #     belongs_to :project, :finder => :find_by_title!
+      #
+      #   This will make your projects be instantiated as:
+      #
+      #     Project.find_by_title!(params[:project_id])
+      #
+      #   Instead of:
+      #
+      #     Project.find(params[:project_id])
+      #
+      # * <tt>:param</tt> - Allows you to specify params key to retrieve the id.
+      #                     Default is :association_id, which in this case is :project_id.
+      #
+      # * <tt>:route_name</tt> - Allows you to specify what is the route name in your url
+      #                          helper. By default is association name.
+      #
+      # * <tt>:collection_name</tt> - Tell how to retrieve the next collection. Let's
+      #                               suppose you have Tasks which belongs to Projects
+      #                               which belongs to companies. This will do somewhere
+      #                               down the road:
+      #
+      #      @company.projects
+      #
+      #   But if you want to retrieve instead:
+      #
+      #      @company.admin_projects
+      #
+      #   You supply the collection name.
+      #
+      # * <tt>:polymorphic</tt> - Tell the association is polymorphic.
+      #
+      # * <tt>:singleton</tt> - Tell it's a singleton association.
+      #
+      # * <tt>:optional</tt> - Tell the association is optional (it's a special
+      #                        type of polymorphic association)
+      #
+      def belongs_to(*symbols, &block)
+        options = symbols.extract_options!
+
+        options.symbolize_keys!
+        options.assert_valid_keys(:class_name, :parent_class, :instance_name, :param,
+                                  :finder, :route_name, :collection_name, :singleton,
+                                  :polymorphic, :optional)
+
+        optional    = options.delete(:optional)
+        singleton   = options.delete(:singleton)
+        polymorphic = options.delete(:polymorphic)
+
+        include BelongsToHelpers if self.parents_symbols.empty?
+
+        acts_as_singleton!   if singleton
+        acts_as_polymorphic! if polymorphic || optional
+
+        raise ArgumentError, 'You have to give me at least one association name.' if symbols.empty?
+        raise ArgumentError, 'You cannot define multiple associations with options: #{options.keys.inspect} to belongs to.' unless symbols.size == 1 || options.empty?
+
+        symbols.each do |symbol|
+          symbol = symbol.to_sym
+
+          if polymorphic || optional
+            self.parents_symbols << :polymorphic unless self.parents_symbols.include?(:polymorphic)
+            self.resources_configuration[:polymorphic][:symbols]   << symbol
+            self.resources_configuration[:polymorphic][:optional] ||= optional
+          else
+            self.parents_symbols << symbol
+          end
+
+          config = self.resources_configuration[symbol] = {}
+          config[:parent_class]    = options.delete(:parent_class)
+          config[:parent_class]  ||= (options.delete(:class_name) || symbol).to_s.classify.constantize rescue nil
+          config[:collection_name] = options.delete(:collection_name) || symbol.to_s.pluralize.to_sym
+          config[:instance_name]   = options.delete(:instance_name) || symbol
+          config[:param]           = options.delete(:param) || :"#{symbol}_id"
+          config[:finder]          = options.delete(:finder) || :find
+          config[:route_name]      = options.delete(:route_name) || symbol
+        end
+
+        if block_given?
+          class_eval(&block)
+        else
+          create_resources_url_helpers!
+        end
+      end
+      alias :nested_belongs_to :belongs_to
+
+      # A quick method to declare polymorphic belongs to.
+      #
+      def polymorphic_belongs_to(*symbols, &block)
+        options = symbols.extract_options!
+        options.merge!(:polymorphic => true)
+        belongs_to(*symbols << options, &block)
+      end
+
+      # A quick method to declare singleton belongs to.
+      #
+      def singleton_belongs_to(*symbols, &block)
+        options = symbols.extract_options!
+        options.merge!(:singleton => true)
+        belongs_to(*symbols << options, &block)
+      end
+
+      # A quick method to declare optional belongs to.
+      #
+      def optional_belongs_to(*symbols, &block)
+        options = symbols.extract_options!
+        options.merge!(:optional => true)
+        belongs_to(*symbols << options, &block)
+      end
+
+    private
+
+      def acts_as_singleton! #:nodoc:
+        unless self.resources_configuration[:self][:singleton]
+          self.resources_configuration[:self][:singleton] = true
+          include SingletonHelpers
+          actions :all, :except => :index
+        end
+      end
+
+      def acts_as_polymorphic! #:nodoc:
+        unless self.parents_symbols.include?(:polymorphic)
+          include PolymorphicHelpers
+          helper_method :parent, :parent_type, :parent_class, :parent?
+        end
+      end
+
+      # Initialize resources class accessors and set their default values.
+      #
+      def initialize_resources_class_accessors! #:nodoc:
+        # Initialize resource class
+        self.resource_class = begin
+          self.controller_name.classify.constantize
+        rescue NameError
+          nil
+        end
+
+        # Initialize resources configuration hash
+        self.resources_configuration ||= {}
+        config = self.resources_configuration[:self] = {}
+        config[:collection_name] = self.controller_name.to_sym
+        config[:instance_name]   = self.controller_name.singularize.to_sym
+
+        config[:route_collection_name] = config[:collection_name]
+        config[:route_instance_name]   = config[:instance_name]
+
+        # Deal with namespaced controllers
+        namespaces = self.controller_path.split('/')[0..-2]
+        config[:route_prefix] = namespaces.join('_') unless namespaces.empty?
+
+        # Initialize polymorphic, singleton, scopes and belongs_to parameters
+        self.parents_symbols      ||= []
+        self.scopes_configuration ||= {}
+        self.resources_configuration[:polymorphic] ||= { :symbols => [], :optional => false }
+      end
+
+      # Hook called on inheritance.
+      #
+      def inherited(base) #:nodoc:
+        super(base)
+        base.send :initialize_resources_class_accessors!
+        base.send :create_resources_url_helpers!
+      end
+
+  end
+end
@@ -0,0 +1,20 @@
+module InheritedResources
+  # = Dumb Responder
+  #
+  # This responder discards all messages sent to him.
+  #
+  class DumbResponder
+
+    instance_methods.each do |m|
+      undef_method m unless m =~ /^__/
+    end
+
+    # This is like a good husband, he will just listen everything that his wife
+    # says (which is a lot) without complaining. :)
+    #
+    def method_missing(*args)
+      nil
+    end
+
+  end
+end
@@ -0,0 +1,65 @@
+module InheritedResources
+
+  # = has_scopes
+  #
+  # This module in included in your controller when has_scope is called for the
+  # first time.
+  #
+  module HasScopeHelpers
+    TRUE_VALUES = ["true", true, "1", 1] unless self.const_defined?(:TRUE_VALUES)
+
+    protected
+
+      # Overwrites apply to scope to implement default scope logic.
+      #
+      def apply_scope_to(target_object) #:nodoc:
+        @current_scopes ||= {}
+
+        self.scopes_configuration.each do |scope, options|
+          next unless apply_scope_to_action?(options)
+          key = options[:key]
+
+          if params.key?(key)
+            value, call_scope = params[key], true
+          elsif options.key?(:default)
+            value, call_scope = options[:default], true
+            value = value.call(self) if value.is_a?(Proc)
+          end
+
+          if call_scope
+            @current_scopes[key] = value
+
+            if options[:boolean]
+              target_object = target_object.send(scope) if TRUE_VALUES.include?(value)
+            else
+              target_object = target_object.send(scope, value)
+            end
+          end
+        end
+
+        target_object
+      end
+
+      # Given an options with :only and :except arrays, check if the scope
+      # can be performed in the current action.
+      #
+      def apply_scope_to_action?(options) #:nodoc:
+        if options[:only].empty?
+          if options[:except].empty?
+            true
+          else
+            !options[:except].include?(action_name.to_sym)
+          end
+        else
+          options[:only].include?(action_name.to_sym)
+        end
+      end
+
+      # Returns the scopes used in this action.
+      #
+      def current_scopes
+        @current_scopes || {}
+      end
+
+  end
+end
@@ -0,0 +1,156 @@
+module InheritedResources
+
+  # = polymorphic associations
+  #
+  # In some cases you have a resource that belongs to two different resources
+  # but not at the same time. For example, let's suppose you have File, Message
+  # and Task as resources and they are all commentable.
+  #
+  # Polymorphic associations allows you to create just one controller that will
+  # deal with each case.
+  #
+  #   class Comment < InheritedResources::Base
+  #     belongs_to :file, :message, :task, :polymorphic => true
+  #   end
+  #
+  # Your routes should be something like:
+  #
+  #   m.resources :files,    :has_many => :comments #=> /files/13/comments
+  #   m.resources :tasks,    :has_many => :comments #=> /tasks/17/comments
+  #   m.resources :messages, :has_many => :comments #=> /messages/11/comments
+  #
+  # When using polymorphic associations, you get some free helpers:
+  #
+  #   parent?         #=> true
+  #   parent_type     #=> :task
+  #   parent_class    #=> Task
+  #   parent          #=> @task
+  #
+  # This polymorphic controllers thing is a great idea by James Golick and he
+  # built it in resource_controller. Here is just a re-implementation.
+  #
+  # = optional polymorphic associations
+  #
+  # Let's take another break from ProjectsController. Let's suppose we are
+  # building a store, which sell products.
+  #
+  # On the website, we can show all products, but also products scoped to
+  # categories, brands, users. In this case case, the association is optional, and
+  # we deal with it in the following way:
+  #
+  #   class ProductsController < InheritedResources::Base
+  #     belongs_to :category, :brand, :user, :polymorphic => true, :optional => true
+  #   end
+  #
+  # This will handle all those urls properly:
+  #
+  #   /products/1
+  #   /categories/2/products/5
+  #   /brands/10/products/3
+  #   /user/13/products/11
+  #
+  # = nested polymorphic associations
+  #
+  # You can have polymorphic associations with nested resources. Let's suppose
+  # that our File, Task and Message resources in the previous example belongs to
+  # a project.
+  #
+  # This way we can have:
+  #
+  #   class CommentsController < InheritedResources::Base
+  #     belongs_to :project {
+  #       belongs_to :file, :message, :task, :polymorphic => true
+  #     }
+  #   end
+  #
+  # Or:
+  #
+  #   class CommentsController < InheritedResources::Base
+  #     nested_belongs_to :project
+  #     nested_belongs_to :file, :message, :task, :polymorphic => true
+  #   end
+  #
+  # Choose the syntax that makes more sense to you. :)
+  #
+  # Finally your routes should be something like:
+  #
+  #   map.resources :projects do |m|
+  #     m.resources :files,    :has_many => :comments #=> /projects/1/files/13/comments
+  #     m.resources :tasks,    :has_many => :comments #=> /projects/1/tasks/17/comments
+  #     m.resources :messages, :has_many => :comments #=> /projects/1/messages/11/comments
+  #   end
+  #
+  # The helpers work in the same way as above.
+  #
+  module PolymorphicHelpers
+
+    protected
+
+      # Returns the parent type. A Comments class can have :task, :file, :note
+      # as parent types.
+      #
+      def parent_type
+        @parent_type
+      end
+
+      def parent_class
+        parent.class if @parent_type
+      end
+
+      # Returns the parent object. They are also available with the instance
+      # variable name: @task, @file, @note...
+      #
+      def parent
+        instance_variable_get("@#{@parent_type}") if @parent_type
+      end
+
+      # If the polymorphic association is optional, we might not have a parent.
+      #
+      def parent?
+        if resources_configuration[:polymorphic][:optional]
+          parents_symbols.size > 1 || !@parent_type.nil?
+        else
+          true
+        end
+      end
+
+    private
+
+      # Maps parents_symbols to build association chain.
+      #
+      # If the parents_symbols find :polymorphic, it goes through the
+      # params keys to see which polymorphic parent matches the given params.
+      #
+      # When optional is given, it does not raise errors if the polymorphic
+      # params are missing.
+      #
+      def symbols_for_association_chain #:nodoc:
+        polymorphic_config = resources_configuration[:polymorphic]
+
+        parents_symbols.map do |symbol|
+          if symbol == :polymorphic
+            params_keys = params.keys
+
+            key = polymorphic_config[:symbols].find do |poly|
+              params_keys.include? resources_configuration[poly][:param].to_s
+            end
+
+            if key.nil?
+              raise ScriptError, "Could not find param for polymorphic association.
+                                  The request params keys are #{params.keys.inspect}
+                                  and the polymorphic associations are
+                                  #{polymorphic_symbols.inspect}." unless polymorphic_config[:optional]
+
+              nil
+            else
+              @parent_type = key.to_sym
+            end
+          else
+            symbol
+          end
+        end.compact
+      end
+
+  end
+end
+
@@ -0,0 +1,339 @@
+module ActionController
+  # Provides an extension for Rails respond_to by expading MimeResponds::Responder
+  # and adding respond_to class method and respond_with instance method.
+  #
+  class Base
+
+    protected
+      # Defines respond_to method to store formats that are rendered by default.
+      #
+      # Examples:
+      #
+      #   respond_to :html, :xml, :json
+      #
+      # All actions on your controller will respond to :html, :xml and :json.
+      # But if you want to specify it based on your actions, you can use only and
+      # except:
+      #
+      #   respond_to :html
+      #   respond_to :xml, :json, :except => [ :edit ]
+      #
+      # The definition above explicits that all actions respond to :html. And all
+      # actions except :edit respond to :xml and :json.
+      #
+      # You can specify also only parameters:
+      #
+      #   respond_to :rjs, :only => :create
+      #
+      # Which would be the same as:
+      #
+      #   respond_to :rjs => :create
+      #
+      def self.respond_to(*formats)
+        options = formats.extract_options!
+        formats_hash = {}
+
+        only_actions   = Array(options.delete(:only))
+        except_actions = Array(options.delete(:except))
+
+        only_actions.map!{ |a| a.to_sym }
+        except_actions.map!{ |a| a.to_sym }
+
+        formats.each do |format|
+          formats_hash[format.to_sym]          = {}
+          formats_hash[format.to_sym][:only]   = only_actions   unless only_actions.empty?
+          formats_hash[format.to_sym][:except] = except_actions unless except_actions.empty?
+        end
+
+        options.each do |format, actions|
+          formats_hash[format.to_sym] = {}
+          next if actions == :all || actions == 'all'
+
+          actions = Array(actions)
+          actions.map!{ |a| a.to_sym }
+
+          formats_hash[format.to_sym][:only] = actions unless actions.empty?
+        end
+
+        write_inheritable_hash(:formats_for_respond_to, formats_hash)
+      end
+      class_inheritable_reader :formats_for_respond_to
+
+      # Method to clear all respond_to declared until the current controller.
+      # This is like freeing the controller from the inheritance chain. :)
+      #
+      def self.clear_respond_to!
+        formats = formats_for_respond_to
+        formats.each { |k,v| formats[k] = { :only => [] } }
+        write_inheritable_hash(:formats_for_respond_to, formats)
+      end
+
+      # By default, responds only to :html
+      respond_to :html
+
+      # If ApplicationController is already defined around here, we recriate
+      # the formats_for_respond_to hash. Since we respond only to :html by
+      # default, this is as easy as settings the :formats_for_respond_to key
+      # to {:html=>{}}.
+      #
+      if defined?(ApplicationController)
+        if inheritable = ApplicationController.instance_variable_get("@inheritable_attributes")
+          inheritable.merge!(:formats_for_respond_to => {:html => {}}) if inheritable
+        end
+      end
+
+      # respond_with accepts an object and tries to render a view based in the
+      # controller and actions that called respond_with. If the view cannot be
+      # found, it will try to call :to_format in the object.
+      #
+      #   class ProjectsController < ApplicationController
+      #     respond_to :html, :xml
+      #
+      #     def show
+      #       @project = Project.find(:id)
+      #       respond_with(@project)
+      #     end
+      #   end
+      #
+      # When the client request a xml, we will check first for projects/show.xml
+      # if it can't be found, we will call :to_xml in the object @project. If the
+      # object eventually doesn't respond to :to_xml it will render 404.
+      #
+      # If you want to overwrite the formats specified in the class, you can
+      # send your new formats using the options :to.
+      #
+      #     def show
+      #       @project = Project.find(:id)
+      #       respond_with(@project, :to => :json)
+      #     end
+      #
+      # That means that this action will ONLY reply to json requests.
+      #
+      # All other options sent will be forwarded to the render method. So you can
+      # do:
+      #
+      #    def create
+      #       # ... 
+      #       if @project.save
+      #         respond_with(@project, :status => :ok, :location => @project)
+      #       else
+      #         respond_with(@project.errors, :status => :unprocessable_entity)
+      #      end
+      #    end
+      #
+      # respond_with does not accept blocks, if you want advanced configurations
+      # check respond_to method sending :with => @object as option.
+      #
+      # Returns true if anything is rendered. Returns false otherwise.
+      #
+      def respond_with(object, options = {})
+        attempt_to_respond = false
+
+        responder             = options.delete(:responder) || Responder.new(self)
+        skip_not_acceptable   = options.delete(:skip_not_acceptable)
+        skip_default_template = options.delete(:skip_default_template)
+
+        mime_types = Array(options.delete(:to))
+        mime_types.map!{ |mime| mime.to_sym }
+
+        for priority in responder.mime_type_priority
+          if !skip_default_template && priority == Mime::ALL && respond_to_default_template?(responder)
+            render options.merge(:action => action_name)
+            return true
+
+          elsif responder.action_respond_to_format?(priority.to_sym, mime_types)
+            attempt_to_respond = true
+            response.template.template_format = priority.to_sym
+            response.content_type = priority.to_s
+
+            if template_exists?
+              render options.merge(:action => action_name)
+              return true
+            elsif object.respond_to?(:"to_#{priority.to_sym}")
+              render options.merge(:text => object.send(:"to_#{priority.to_sym}"))
+              return true
+            end
+          end
+        end
+
+        # If we got here we could not render the object. But if attempted to
+        # render (this means, the format sent by the client was valid) we should
+        # render a 404.
+        #
+        # If we even didn't attempt to respond, we respond :not_acceptable
+        # unless is told otherwise.
+        #
+        if attempt_to_respond
+          render :text => '404 Not Found', :status => 404
+          return true
+        elsif !skip_not_acceptable
+          head :not_acceptable
+          return false
+        end
+
+        return false
+      end
+
+      # Extends respond_to behaviour.
+      #
+      # You can now pass objects using the options :with.
+      #
+      #   respond_to(:html, :xml, :rjs, :with => @project)
+      #
+      # If you pass an object and send any block, it's exactly the same as:
+      #
+      #   respond_with(@project, :to => [:html, :xml, :rjs])
+      #
+      # But the main difference of respond_to and respond_with is that the first
+      # allows further customizations:
+      #
+      #   respond_to(:html, :with => @project) do |format|
+      #     format.xml { render :xml => @project.errors  }
+      #   end
+      #
+      # It's the same as:
+      #
+      #   1. When responding to html, execute respond_with(@object).
+      #   2. When accessing a xml, execute the block given.
+      #
+      # Formats defined in blocks have precedence to formats sent as arguments.
+      # In other words, if you pass a format as argument and as block, the block
+      # will always be executed.
+      #
+      # And as in respond_with, all extra options sent will be forwarded to 
+      # the render method:
+      #
+      #   respond_to(:with => @projects.errors, :status => :unprocessable_entity) do |format|
+      #     format.html { render :template => 'new' }
+      #   end
+      #
+      # It also accepts an option called prioritize. It allows you to put a
+      # format as first, and then when Mime::ALL is sent, it will be the one
+      # used as response.
+      #
+      def respond_to(*types, &block)
+        options = types.extract_options!
+
+        object     = options.delete(:with)
+        responder  = options.delete(:responder) || Responder.new(self)
+        prioritize = options.delete(:prioritize)
+
+        if object.nil?
+          block ||= lambda { |responder| types.each { |type| responder.send(type) } }
+          block.call(responder)
+          responder.respond
+          return true
+        else
+          # Even if Mime::ALL is sent by the client, we do not respond_to it now.
+          # This is done using calling :respond_except_any instead of :respond.
+          #
+          if block_given?
+            block.call(responder)
+            return true if responder.respond_except_any
+          end
+
+          # If the block includes the default template format, we don't render
+          # the default template (which uses the default_template_format).
+          options.merge!(:to => types, :responder => responder, :skip_not_acceptable => true,
+                         :skip_default_template => responder.order.include?(default_template_format))
+
+          if respond_with(object, options)
+            return true
+          elsif block_given?
+            responder.prioritize(prioritize) if prioritize
+            return true if responder.respond_any
+          end
+        end
+
+        head :not_acceptable
+        return false
+      end
+
+    private
+
+      unless ActionController::Base.private_instance_methods.include?('template_exists?') ||
+             ActionController::Base.private_instance_methods.include?(:template_exists?)
+
+        # Define template_exists? for Rails 2.3
+        def template_exists?
+          default_template ? true : false
+        rescue ActionView::MissingTemplate
+          false
+        end
+      end
+
+      # We respond to the default template if it's a valid format AND the template
+      # exists.
+      #
+      def respond_to_default_template?(responder) #:nodoc:
+        responder.action_respond_to_format?(default_template_format) && template_exists?
+      end
+
+  end
+
+  module MimeResponds #:nodoc:
+    class Responder #:nodoc:
+
+      attr_reader :mime_type_priority, :order
+
+      # Similar as respond but if we can't find a valid mime type, we do not
+      # send :not_acceptable message as head and it does not respond to
+      # Mime::ALL in any case.
+      #
+      def respond_except_any
+        for priority in @mime_type_priority
+          next if priority == Mime::ALL
+
+          if @responses[priority]
+            @responses[priority].call
+            return true
+          end
+        end
+
+        false
+      end
+
+      # Respond to the first format given if Mime::ALL is included in the
+      # mime type priorites. This is the behaviour expected when the client
+      # sends "*/*" as mime type.
+      #
+      def respond_any
+        any = @responses[@order.include?(Mime::ALL) ? Mime::ALL : @order.first]
+
+        if any && @mime_type_priority.include?(Mime::ALL)
+          any.call
+          return true
+        end
+      end
+
+      # Receives an format and checks if the current action responds to
+      # the given format. If additional mimes are sent, only them are checked.
+      #
+      def action_respond_to_format?(format, additional_mimes = [])
+        if !additional_mimes.blank?
+          additional_mimes.include?(format.to_sym)
+        elsif formats = @controller.formats_for_respond_to[format.to_sym]
+          if formats[:only]
+            formats[:only].include?(@controller.action_name.to_sym)
+          elsif formats[:except]
+            !formats[:except].include?(@controller.action_name.to_sym)
+          else
+            true
+          end
+        else
+          false
+        end
+      end
+
+      # Makes a given format the first in the @order array.
+      #
+      def prioritize(format)
+        if index = @order.index(format)
+          @order.unshift(@order.delete_at(index))
+        end
+        @order
+      end
+
+    end
+  end
+end
@@ -0,0 +1,95 @@
+module InheritedResources
+
+  # = singleton
+  #
+  # Singletons are usually used in associations which are related through has_one
+  # and belongs_to. You declare those associations like this:
+  #
+  #   class ManagersController < InheritedResources::Base
+  #     belongs_to :project, :singleton => true
+  #   end
+  #
+  # But in some cases, like an AccountsController, you have a singleton object
+  # that is not necessarily associated with another:
+  #
+  #   class AccountsController < InheritedResources::Base
+  #     defaults :singleton => true
+  #   end
+  #
+  # Besides that, you should overwrite the methods :resource and :build_resource
+  # to make it work properly:
+  #
+  #   class AccountsController < InheritedResources::Base
+  #     defaults :singleton => true
+  #
+  #     protected
+  #       def resource
+  #         @current_user.account
+  #       end
+  #
+  #       def build_resource(attributes = {})
+  #         Account.new(attributes)
+  #       end
+  #   end
+  #
+  # When you have a singleton controller, the action index is removed.
+  #
+  module SingletonHelpers
+
+    protected
+
+      # Singleton methods does not deal with collections.
+      #
+      def collection
+        nil
+      end
+
+      # Overwrites how singleton deals with resource.
+      #
+      # If you are going to overwrite it, you should notice that the
+      # end_of_association_chain here is not the same as in default belongs_to.
+      #
+      #   class TasksController < InheritedResources::Base
+      #     belongs_to :project
+      #   end
+      #
+      # In this case, the association chain would be:
+      #
+      #   Project.find(params[:project_id]).tasks
+      #
+      # So you would just have to call find(:all) at the end of association
+      # chain. And this is what happened.
+      #
+      # In singleton controllers:
+      #
+      #   class ManagersController < InheritedResources::Base
+      #     belongs_to :project, :singleton => true
+      #   end
+      #
+      # The association chain will be:
+      #
+      #   Project.find(params[:project_id])
+      #
+      # So we have to call manager on it, not find.
+      #
+      def resource
+        get_resource_ivar || set_resource_ivar(end_of_association_chain.send(resource_instance_name))
+      end
+
+    private
+
+      # Returns the appropriated method to build the resource.
+      #
+      def method_for_association_build #:nodoc:
+        :"build_#{resource_instance_name}"
+      end
+
+      # Sets the method_for_association_chain to nil. See <tt>resource</tt>
+      # above for more information.
+      #
+      def method_for_association_chain #:nodoc:
+        nil
+      end
+
+  end
+end
@@ -0,0 +1,173 @@
+module InheritedResources
+  # = URLHelpers
+  #
+  # When you use InheritedResources it creates some UrlHelpers for you.
+  # And they handle everything for you.
+  #
+  #  # /posts/1/comments
+  #  resource_url          # => /posts/1/comments/#{@comment.to_param}
+  #  resource_url(comment) # => /posts/1/comments/#{comment.to_param}
+  #  new_resource_url      # => /posts/1/comments/new
+  #  edit_resource_url     # => /posts/1/comments/#{@comment.to_param}/edit
+  #  collection_url        # => /posts/1/comments
+  #
+  #  # /projects/1/tasks
+  #  resource_url          # => /products/1/tasks/#{@task.to_param}
+  #  resource_url(task)    # => /products/1/tasks/#{task.to_param}
+  #  new_resource_url      # => /products/1/tasks/new
+  #  edit_resource_url     # => /products/1/tasks/#{@task.to_param}/edit
+  #  collection_url        # => /products/1/tasks
+  #
+  #  # /users
+  #  resource_url          # => /users/#{@user.to_param}
+  #  resource_url(user)    # => /users/#{user.to_param}
+  #  new_resource_url      # => /users/new
+  #  edit_resource_url     # => /users/#{@user.to_param}/edit
+  #  collection_url        # => /users
+  #
+  # The nice thing is that those urls are not guessed during runtime. They are
+  # all created when you inherit.
+  #
+  module UrlHelpers
+
+    # This method hard code url helpers in the class.
+    #
+    # We are doing this because is cheaper than guessing them when our action
+    # is being processed (and even more cheaper when we are using nested
+    # resources).
+    #
+    # When we are using polymorphic associations, those helpers rely on 
+    # polymorphic_url Rails helper.
+    #
+    def create_resources_url_helpers!
+      resource_segments, resource_ivars = [], []
+      resource_config = self.resources_configuration[:self]
+
+      singleton   = self.resources_configuration[:self][:singleton]
+      polymorphic = self.parents_symbols.include?(:polymorphic)
+
+      # Add route_prefix if any.
+      unless resource_config[:route_prefix].blank?
+        if polymorphic
+          resource_ivars << resource_config[:route_prefix].to_s.inspect
+        else
+          resource_segments << resource_config[:route_prefix]
+        end
+      end
+
+      # Deal with belongs_to associations and polymorphic associations.
+      # Remember that we don't have to build the segments in polymorphic cases,
+      # because the url will be polymorphic_url.
+      #
+      self.parents_symbols.each do |symbol|
+        if symbol == :polymorphic
+          resource_ivars << :parent
+        else
+          config = self.resources_configuration[symbol]
+          resource_segments << config[:route_name]
+          resource_ivars    << :"@#{config[:instance_name]}"
+        end
+      end
+
+      collection_ivars    = resource_ivars.dup
+      collection_segments = resource_segments.dup
+
+      # This is the default route configuration, later we have to deal with
+      # exception from polymorphic and singleton cases.
+      #
+      collection_segments << resource_config[:route_collection_name]
+      resource_segments   << resource_config[:route_instance_name]
+      resource_ivars      << :"@#{resource_config[:instance_name]}"
+
+      # In singleton cases, we do not send the current element instance variable
+      # because the id is not in the URL. For example, we should call:
+      #
+      #   project_manager_url(@project)
+      #
+      # Instead of:
+      #
+      #   project_manager_url(@project, @manager)
+      #
+      # Another exception in singleton cases is that collection url does not
+      # exist. In such cases, we create the parent collection url. So in the
+      # manager case above, the collection url will be:
+      #
+      #    project_url(@project)
+      #
+      # If the singleton does not have a parent, it will default to root_url.
+      #
+      # Finally, polymorphic cases we have to give hints to the polymorphic url
+      # builder. This works by attaching new ivars as symbols or records.
+      #
+      if singleton
+        collection_segments.pop
+        resource_ivars.pop
+
+        if polymorphic
+          resource_ivars << resource_config[:instance_name].inspect
+          new_ivars       = resource_ivars
+        end
+      elsif polymorphic
+        collection_ivars << '(@_resource_class_new ||= resource_class.new)'
+      end
+
+      generate_url_and_path_helpers nil,   :collection, collection_segments, collection_ivars
+      generate_url_and_path_helpers :new,  :resource,   resource_segments,   new_ivars || collection_ivars
+      generate_url_and_path_helpers nil,   :resource,   resource_segments,   resource_ivars
+      generate_url_and_path_helpers :edit, :resource,   resource_segments,   resource_ivars
+    end
+
+    def generate_url_and_path_helpers(prefix, name, resource_segments, resource_ivars) #:nodoc:
+      ivars = resource_ivars.dup
+
+      singleton   = self.resources_configuration[:self][:singleton]
+      polymorphic = self.parents_symbols.include?(:polymorphic)
+
+      # If it's not a singleton, ivars are not empty, not a collection or
+      # not a "new" named route, we can pass a resource as argument.
+      #
+      unless singleton || ivars.empty? || name == :collection || prefix == :new
+        ivars.push "(given_args.first || #{ivars.pop})"
+      end
+
+      # In collection in polymorphic cases, allow an argument to be given as a
+      # replacemente for the parent.
+      #
+      if name == :collection && polymorphic
+        index = ivars.index(:parent)
+        ivars.insert index, "(given_args.first || parent)"
+        ivars.delete(:parent)
+      end
+
+      # When polymorphic is true, the segments must be replace by :polymorphic
+      # and ivars should be gathered into an array, which is compacted when
+      # optional.
+      #
+      if polymorphic
+        segments = :polymorphic
+        ivars    = "[#{ivars.join(', ')}]"
+        ivars   << '.compact' if self.resources_configuration[:polymorphic][:optional]
+      else
+        segments = resource_segments.empty? ? 'root' : resource_segments.join('_')
+        ivars    = ivars.join(', ')
+      end
+
+      prefix = prefix ? "#{prefix}_" : ''
+      ivars << (ivars.empty? ? 'given_options' : ', given_options')
+
+      class_eval <<-URL_HELPERS, __FILE__, __LINE__
+        protected
+          def #{prefix}#{name}_path(*given_args)
+            given_options = given_args.extract_options!
+            #{prefix}#{segments}_path(#{ivars})
+          end
+
+          def #{prefix}#{name}_url(*given_args)
+            given_options = given_args.extract_options!
+            #{prefix}#{segments}_url(#{ivars})
+          end
+      URL_HELPERS
+    end
+
+  end
+end
@@ -0,0 +1,134 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class Student;
+  def self.human_name; 'Student'; end
+end
+
+class StudentsController < ApplicationController
+  inherit_resources
+
+  def edit
+    edit! do |format|
+      format.xml { render :text => 'Render XML' }
+    end
+  end
+
+  def new
+    @something = 'magical'
+    new!
+  end
+
+  def create
+    create! do |success, failure|
+      success.html { render :text => "I won't redirect!" }
+      failure.xml { render :text => "I shouldn't be rendered" }
+    end
+  end
+
+  def update
+    update! do |success, failure|
+      success.html { redirect_to(resource_url) }
+      failure.html { render :text => "I won't render!" }
+    end
+  end
+
+  def destroy
+    destroy! do |format|
+      format.html { render :text => "Destroyed!" }
+    end
+  end
+
+end
+
+class AliasesTest < ActionController::TestCase
+  tests StudentsController
+
+  def test_assignments_before_calling_alias
+    Student.stubs(:new).returns(mock_student)
+    get :new
+    assert_response :success
+    assert_equal 'magical', assigns(:something)
+  end
+
+  def test_controller_should_render_new
+    Student.stubs(:new).returns(mock_student)
+    get :new
+    assert_response :success
+    assert_equal 'New HTML', @response.body.strip
+  end
+
+  def test_expose_the_resquested_user_on_edit
+    Student.expects(:find).with('42').returns(mock_student)
+    get :edit, :id => '42'
+    assert_equal mock_student, assigns(:student)
+    assert_response :success
+  end
+
+  def test_controller_should_render_edit
+    Student.stubs(:find).returns(mock_student)
+    get :edit
+    assert_response :success
+    assert_equal 'Edit HTML', @response.body.strip
+  end
+
+  def test_render_xml_when_it_is_given_as_a_block
+    @request.accept = 'application/xml'
+    Student.stubs(:find).returns(mock_student)
+    get :edit
+    assert_response :success
+    assert_equal 'Render XML', @response.body
+  end
+
+  def test_is_not_redirected_on_create_with_success_if_success_block_is_given
+    Student.stubs(:new).returns(mock_student(:save => true))
+    @controller.stubs(:resource_url).returns('http://test.host/')
+    post :create
+    assert_response :success
+    assert_equal "I won't redirect!", @response.body
+  end
+
+  def test_dumb_responder_quietly_receives_everything_on_failure
+    @request.accept = 'text/html'
+    Student.stubs(:new).returns(mock_student(:save => false, :errors => []))
+    @controller.stubs(:resource_url).returns('http://test.host/')
+    post :create
+    assert_response :success
+    assert_equal "New HTML", @response.body.strip
+  end
+
+  def test_html_is_the_default_when_only_xml_is_overwriten
+    @request.accept = '*/*'
+    Student.stubs(:new).returns(mock_student(:save => false, :errors => []))
+    @controller.stubs(:resource_url).returns('http://test.host/')
+    post :create
+    assert_response :success
+    assert_equal "New HTML", @response.body.strip
+  end
+
+  def test_wont_render_edit_template_on_update_with_failure_if_failure_block_is_given
+    Student.stubs(:find).returns(mock_student(:update_attributes => false, :errors => []))
+    put :update
+    assert_response :success
+    assert_equal "I won't render!", @response.body
+  end
+
+  def test_dumb_responder_quietly_receives_everything_on_success
+    Student.stubs(:find).returns(mock_student(:update_attributes => true))
+    @controller.stubs(:resource_url).returns('http://test.host/')
+    put :update, :id => '42', :student => {:these => 'params'}
+    assert_equal mock_student, assigns(:student)
+  end
+
+  def test_block_is_called_when_student_is_destroyed
+    Student.stubs(:find).returns(mock_student(:destroy => true))
+    delete :destroy
+    assert_response :success
+    assert_equal "Destroyed!", @response.body
+  end
+
+  protected
+    def mock_student(stubs={})
+      @mock_student ||= mock(stubs)
+    end
+end
+
@@ -0,0 +1,70 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class Pet
+  def self.human_name; 'Pet'; end
+end
+
+class PetsController < InheritedResources::Base
+  attr_accessor :current_user
+  
+  def edit
+    @pet = 'new pet'
+    edit!
+  end
+
+  protected
+    def collection
+      @pets ||= end_of_association_chain.all
+    end
+
+    def begin_of_association_chain
+      @current_user
+    end
+end
+
+class AssociationChainBaseHelpersTest < ActionController::TestCase
+  tests PetsController
+
+  def setup
+    @controller.current_user = mock()
+  end
+
+  def test_begin_of_association_chain_is_called_on_index
+    @controller.current_user.expects(:pets).returns(Pet)
+    Pet.expects(:all).returns(mock_pet)
+    get :index
+    assert_response :success
+    assert 'Index HTML', @response.body.strip
+  end
+
+  def test_begin_of_association_chain_is_called_on_new
+    @controller.current_user.expects(:pets).returns(Pet)
+    Pet.expects(:build).returns(mock_pet)
+    get :new
+    assert_response :success
+    assert 'New HTML', @response.body.strip
+  end
+
+  def test_begin_of_association_chain_is_called_on_show
+    @controller.current_user.expects(:pets).returns(Pet)
+    Pet.expects(:find).with('47').returns(mock_pet)
+    get :show, :id => '47'
+    assert_response :success
+    assert 'Show HTML', @response.body.strip
+  end
+
+  def test_instance_variable_should_not_be_set_if_already_defined
+    @controller.current_user.expects(:pets).never
+    Pet.expects(:find).never
+    get :edit
+    assert_response :success
+    assert_equal 'new pet', assigns(:pet)
+  end
+
+  protected
+    def mock_pet(stubs={})
+      @mock_pet ||= mock(stubs)
+    end
+
+end
+
@@ -0,0 +1,219 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class User
+  def self.human_name; 'User'; end
+end
+
+class AccountsController < InheritedResources::Base
+end
+
+class UsersController < AccountsController
+  respond_to :html, :xml
+end
+
+module UserTestHelper
+  def setup
+    @controller          = UsersController.new
+    @controller.request  = @request  = ActionController::TestRequest.new
+    @controller.response = @response = ActionController::TestResponse.new
+  end
+
+  protected
+    def mock_user(stubs={})
+      @mock_user ||= mock(stubs)
+    end
+end
+
+class IndexActionBaseTest < ActionController::TestCase
+  include UserTestHelper
+
+  def test_expose_all_users_as_instance_variable
+    User.expects(:find).with(:all).returns([mock_user])
+    get :index
+    assert_equal [mock_user], assigns(:users)
+  end
+
+  def test_controller_should_render_index
+    User.stubs(:find).returns([mock_user])
+    get :index
+    assert_response :success
+    assert_equal 'Index HTML', @response.body.strip
+  end
+
+  def test_render_all_users_as_xml_when_mime_type_is_xml
+    @request.accept = 'application/xml'
+    User.expects(:find).with(:all).returns(mock_user)
+    mock_user.expects(:to_xml).returns('Generated XML')
+    get :index
+    assert_response :success
+    assert_equal 'Generated XML', @response.body
+  end
+end
+
+class ShowActionBaseTest < ActionController::TestCase
+  include UserTestHelper
+
+  def test_expose_the_resquested_user
+    User.expects(:find).with('42').returns(mock_user)
+    get :show, :id => '42'
+    assert_equal mock_user, assigns(:user)
+  end
+
+  def test_controller_should_render_show
+    User.stubs(:find).returns(mock_user)
+    get :show
+    assert_response :success
+    assert_equal 'Show HTML', @response.body.strip
+  end
+
+  def test_render_exposed_user_as_xml_when_mime_type_is_xml
+    @request.accept = 'application/xml'
+    User.expects(:find).with('42').returns(mock_user)
+    mock_user.expects(:to_xml).returns("Generated XML")
+    get :show, :id => '42'
+    assert_response :success
+    assert_equal 'Generated XML', @response.body
+  end
+end
+
+class NewActionBaseTest < ActionController::TestCase
+  include UserTestHelper
+
+  def test_expose_a_new_user
+    User.expects(:new).returns(mock_user)
+    get :new
+    assert_equal mock_user, assigns(:user)
+  end
+
+  def test_controller_should_render_new
+    User.stubs(:new).returns(mock_user)
+    get :new
+    assert_response :success
+    assert_equal 'New HTML', @response.body.strip
+  end
+
+  def test_render_exposed_a_new_user_as_xml_when_mime_type_is_xml
+    @request.accept = 'application/xml'
+    User.expects(:new).returns(mock_user)
+    mock_user.expects(:to_xml).returns("Generated XML")
+    get :new
+    assert_response :success
+    assert_equal 'Generated XML', @response.body
+  end
+end
+
+class EditActionBaseTest < ActionController::TestCase
+  include UserTestHelper
+
+  def test_expose_the_resquested_user
+    User.expects(:find).with('42').returns(mock_user)
+    get :edit, :id => '42'
+    assert_response :success
+    assert_equal mock_user, assigns(:user)
+  end
+
+  def test_controller_should_render_edit
+    User.stubs(:find).returns(mock_user)
+    get :edit
+    assert_response :success
+    assert_equal 'Edit HTML', @response.body.strip
+  end
+end
+
+class CreateActionBaseTest < ActionController::TestCase
+  include UserTestHelper
+
+  def test_expose_a_newly_create_user_when_saved_with_success
+    User.expects(:new).with({'these' => 'params'}).returns(mock_user(:save => true))
+    post :create, :user => {:these => 'params'}
+    assert_equal mock_user, assigns(:user)
+  end
+
+  def test_redirect_to_the_created_user
+    User.stubs(:new).returns(mock_user(:save => true))
+    @controller.expects(:resource_url).returns('http://test.host/').times(2)
+    post :create
+    assert_redirected_to 'http://test.host/'
+  end
+
+  def test_show_flash_message_when_success
+    User.stubs(:new).returns(mock_user(:save => true))
+    post :create
+    assert_equal flash[:notice], 'User was successfully created.'
+  end
+
+  def test_render_new_template_when_user_cannot_be_saved
+    User.stubs(:new).returns(mock_user(:save => false, :errors => []))
+    post :create
+    assert_response :success
+    assert_template :new
+  end
+
+  def test_dont_show_flash_message_when_user_cannot_be_saved
+    User.stubs(:new).returns(mock_user(:save => false, :errors => []))
+    post :create
+    assert flash.empty?
+  end
+end
+
+class UpdateActionBaseTest < ActionController::TestCase
+  include UserTestHelper
+
+  def test_update_the_requested_object
+    User.expects(:find).with('42').returns(mock_user)
+    mock_user.expects(:update_attributes).with({'these' => 'params'}).returns(true)
+    put :update, :id => '42', :user => {:these => 'params'}
+    assert_equal mock_user, assigns(:user)
+  end
+
+  def test_redirect_to_the_created_user
+    User.stubs(:find).returns(mock_user(:update_attributes => true))
+    @controller.expects(:resource_url).returns('http://test.host/')
+    put :update
+    assert_redirected_to 'http://test.host/'
+  end
+
+  def test_show_flash_message_when_success
+    User.stubs(:find).returns(mock_user(:update_attributes => true))
+    put :update
+    assert_equal flash[:notice], 'User was successfully updated.'
+  end
+
+  def test_render_edit_template_when_user_cannot_be_saved
+    User.stubs(:find).returns(mock_user(:update_attributes => false, :errors => []))
+    put :update
+    assert_response :success
+    assert_template :edit
+  end
+
+  def test_dont_show_flash_message_when_user_cannot_be_saved
+    User.stubs(:find).returns(mock_user(:update_attributes => false, :errors => []))
+    put :update
+    assert flash.empty?
+  end
+end
+
+class DestroyActionBaseTest < ActionController::TestCase
+  include UserTestHelper
+  
+  def test_the_resquested_user_is_destroyed
+    User.expects(:find).with('42').returns(mock_user)
+    mock_user.expects(:destroy)
+    delete :destroy, :id => '42'
+    assert_equal mock_user, assigns(:user)
+  end
+
+  def test_show_flash_message
+    User.stubs(:find).returns(mock_user(:destroy => true))
+    delete :destroy
+    assert_equal flash[:notice], 'User was successfully destroyed.'
+  end
+
+  def test_redirects_to_users_list
+    User.stubs(:find).returns(mock_user(:destroy => true))
+    @controller.expects(:collection_url).returns('http://test.host/')
+    delete :destroy
+    assert_redirected_to 'http://test.host/'
+  end
+end
+
@@ -0,0 +1,87 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class Post
+end
+
+class Comment
+  def self.human_name; 'Comment'; end
+end
+
+class CommentsController < InheritedResources::Base
+  belongs_to :post
+end
+
+class BelongsToTest < ActionController::TestCase
+  tests CommentsController
+
+  def setup
+    Post.expects(:find).with('37').returns(mock_post)
+    mock_post.expects(:comments).returns(Comment)
+
+    @controller.stubs(:resource_url).returns('/')
+    @controller.stubs(:collection_url).returns('/')
+  end
+
+  def test_expose_all_comments_as_instance_variable_on_index
+    Comment.expects(:find).with(:all).returns([mock_comment])
+    get :index, :post_id => '37'
+    assert_equal mock_post, assigns(:post)
+    assert_equal [mock_comment], assigns(:comments)
+  end
+
+  def test_expose_the_resquested_comment_on_show
+    Comment.expects(:find).with('42').returns(mock_comment)
+    get :show, :id => '42', :post_id => '37'
+    assert_equal mock_post, assigns(:post)
+    assert_equal mock_comment, assigns(:comment)
+  end
+
+  def test_expose_a_new_comment_on_new
+    Comment.expects(:build).returns(mock_comment)
+    get :new, :post_id => '37'
+    assert_equal mock_post, assigns(:post)
+    assert_equal mock_comment, assigns(:comment)
+  end
+
+  def test_expose_the_resquested_comment_on_edit
+    Comment.expects(:find).with('42').returns(mock_comment)
+    get :edit, :id => '42', :post_id => '37'
+    assert_equal mock_post, assigns(:post)
+    assert_equal mock_comment, assigns(:comment)
+  end
+
+  def test_expose_a_newly_create_comment_on_create
+    Comment.expects(:build).with({'these' => 'params'}).returns(mock_comment(:save => true))
+    post :create, :post_id => '37', :comment => {:these => 'params'}
+    assert_equal mock_post, assigns(:post)
+    assert_equal mock_comment, assigns(:comment)
+  end
+
+  def test_update_the_requested_object_on_update
+    Comment.expects(:find).with('42').returns(mock_comment)
+    mock_comment.expects(:update_attributes).with({'these' => 'params'}).returns(true)
+    put :update, :id => '42', :post_id => '37', :comment => {:these => 'params'}
+    assert_equal mock_post, assigns(:post)
+    assert_equal mock_comment, assigns(:comment)
+  end
+
+  def test_the_resquested_comment_is_destroyed_on_destroy
+    Comment.expects(:find).with('42').returns(mock_comment)
+    mock_comment.expects(:destroy)
+    delete :destroy, :id => '42', :post_id => '37'
+    assert_equal mock_post, assigns(:post)
+    assert_equal mock_comment, assigns(:comment)
+  end
+
+  protected
+
+    def mock_post(stubs={})
+      @mock_post ||= mock(stubs)
+    end
+
+    def mock_comment(stubs={})
+      @mock_comment ||= mock(stubs)
+    end
+
+end
+
@@ -0,0 +1,137 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class Book; end
+class Folder; end
+
+class BooksController < InheritedResources::Base
+  actions :index, :show
+end
+
+class ReadersController < InheritedResources::Base
+  actions :all, :except => [ :edit, :update ]
+end
+
+class FoldersController < InheritedResources::Base
+end
+
+class Dean
+  def self.human_name; 'Dean'; end
+end
+
+class SchoolsController < InheritedResources::Base
+  has_scope :by_city
+  has_scope :featured, :boolean => true, :only => :index, :key => :by_featured
+end
+
+class DeansController < InheritedResources::Base
+  belongs_to :school
+end
+
+
+class ActionsClassMethodTest < ActiveSupport::TestCase
+  def test_actions_are_undefined
+    action_methods = BooksController.send(:action_methods)
+    assert_equal 2, action_methods.size
+
+    ['index', 'show'].each do |action|
+      assert action_methods.include? action
+    end
+  end
+
+  def test_actions_are_undefined_when_except_option_is_given
+    action_methods = ReadersController.send(:action_methods)
+    assert_equal 5, action_methods.size
+
+    ['index', 'new', 'show', 'create', 'destroy'].each do |action|
+      assert action_methods.include? action
+    end
+  end
+end
+
+
+class DefaultsClassMethodTest < ActiveSupport::TestCase
+  def test_resource_class_is_set_to_nil_when_resource_model_cannot_be_found
+    assert_nil ReadersController.send(:resource_class)
+  end
+
+  def test_defaults_are_set
+    assert Folder, FoldersController.send(:resource_class)
+    assert :folder, FoldersController.send(:resources_configuration)[:self][:instance_name]
+    assert :folders, FoldersController.send(:resources_configuration)[:self][:collection_name]
+  end
+
+  def test_defaults_can_be_overwriten
+    BooksController.send(:defaults, :resource_class => String, :instance_name => 'string', :collection_name => 'strings')
+
+    assert String, BooksController.send(:resource_class)
+    assert :string, BooksController.send(:resources_configuration)[:self][:instance_name]
+    assert :strings, BooksController.send(:resources_configuration)[:self][:collection_name]
+
+    BooksController.send(:defaults, :class_name => 'Fixnum', :instance_name => :fixnum, :collection_name => :fixnums)
+
+    assert String, BooksController.send(:resource_class)
+    assert :string, BooksController.send(:resources_configuration)[:self][:instance_name]
+    assert :strings, BooksController.send(:resources_configuration)[:self][:collection_name]
+  end
+
+  def test_defaults_raises_invalid_key
+    assert_raise ArgumentError do
+      BooksController.send(:defaults, :boom => String)
+    end
+  end
+
+  def test_url_helpers_are_recreated_when_defaults_change
+    BooksController.expects(:create_resources_url_helpers!).returns(true).once
+    BooksController.send(:defaults, :instance_name => 'string', :collection_name => 'strings')
+  end
+end
+
+class BelongsToErrorsTest < ActiveSupport::TestCase
+  def test_belongs_to_raise_errors_with_invalid_arguments
+    assert_raise ArgumentError do
+      DeansController.send(:belongs_to)
+    end
+
+    assert_raise ArgumentError do
+      DeansController.send(:belongs_to, :nice, :invalid_key => '')
+    end
+  end
+
+  def test_belongs_to_raises_an_error_when_multiple_associations_are_given_with_options
+    assert_raise ArgumentError do
+      DeansController.send(:belongs_to, :arguments, :with_options, :parent_class => Professor)
+    end
+  end
+
+  def test_url_helpers_are_recreated_just_once_when_belongs_to_is_called_with_block
+    DeansController.expects(:create_resources_url_helpers!).returns(true).once
+    DeansController.send(:belongs_to, :school) do
+      belongs_to :association
+    end
+  ensure
+    DeansController.send(:parents_symbols=, [:school])
+  end
+
+  def test_url_helpers_are_recreated_just_once_when_belongs_to_is_called_with_multiple_blocks
+    DeansController.expects(:create_resources_url_helpers!).returns(true).once
+    DeansController.send(:belongs_to, :school) do
+      belongs_to :association do
+        belongs_to :nested
+      end
+    end
+  ensure
+    DeansController.send(:parents_symbols=, [:school])
+  end
+end
+
+class HasScopeClassMethods < ActiveSupport::TestCase
+  def test_scope_configuration_is_stored_as_hashes
+    config = SchoolsController.send(:scopes_configuration)
+
+    assert config.key?(:by_city)
+    assert config.key?(:featured)
+
+    assert_equal config[:by_city], { :key => :by_city, :only => [], :except => [] }
+    assert_equal config[:featured], { :key => :by_featured, :only => [ :index ], :except => [], :boolean => true }
+  end
+end
@@ -0,0 +1,76 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class GreatSchool
+end
+
+class Professor
+  def self.human_name; 'Professor'; end
+end
+
+class ProfessorsController < InheritedResources::Base
+  belongs_to :school, :parent_class => GreatSchool, :instance_name => :great_school,
+                      :finder => :find_by_title!, :param => :school_title
+end
+
+class CustomizedBelongsToTest < ActionController::TestCase
+  tests ProfessorsController
+
+  def setup
+    GreatSchool.expects(:find_by_title!).with('nice').returns(mock_school(:professors => Professor))
+    @controller.stubs(:resource_url).returns('/')
+    @controller.stubs(:collection_url).returns('/')
+  end
+
+  def test_expose_the_resquested_school_with_chosen_instance_variable_on_index
+    Professor.stubs(:find).returns([mock_professor])
+    get :index, :school_title => 'nice'
+    assert_equal mock_school, assigns(:great_school)
+  end
+
+  def test_expose_the_resquested_school_with_chosen_instance_variable_on_show
+    Professor.stubs(:find).returns(mock_professor)
+    get :show, :school_title => 'nice'
+    assert_equal mock_school, assigns(:great_school)
+  end
+
+  def test_expose_the_resquested_school_with_chosen_instance_variable_on_new
+    Professor.stubs(:build).returns(mock_professor)
+    get :new, :school_title => 'nice'
+    assert_equal mock_school, assigns(:great_school)
+  end
+
+  def test_expose_the_resquested_school_with_chosen_instance_variable_on_edit
+    Professor.stubs(:find).returns(mock_professor)
+    get :edit, :school_title => 'nice'
+    assert_equal mock_school, assigns(:great_school)
+  end
+
+  def test_expose_the_resquested_school_with_chosen_instance_variable_on_create
+    Professor.stubs(:build).returns(mock_professor(:save => true))
+    post :create, :school_title => 'nice'
+    assert_equal mock_school, assigns(:great_school)
+  end
+
+  def test_expose_the_resquested_school_with_chosen_instance_variable_on_update
+    Professor.stubs(:find).returns(mock_professor(:update_attributes => true))
+    put :update, :school_title => 'nice'
+    assert_equal mock_school, assigns(:great_school)
+  end
+
+  def test_expose_the_resquested_school_with_chosen_instance_variable_on_destroy
+    Professor.stubs(:find).returns(mock_professor(:destroy => true))
+    delete :destroy, :school_title => 'nice'
+    assert_equal mock_school, assigns(:great_school)
+  end
+
+  protected
+
+    def mock_school(stubs={})
+      @mock_school ||= mock(stubs)
+    end
+
+    def mock_professor(stubs={})
+      @mock_professor ||= mock(stubs)
+    end
+end
+
@@ -0,0 +1,70 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class Malarz
+  def self.human_name; 'Painter'; end
+end
+
+class PaintersController < InheritedResources::Base
+  defaults :instance_name => 'malarz', :collection_name => 'malarze',
+           :resource_class => Malarz, :route_prefix => nil
+end
+
+class DefaultsTest < ActionController::TestCase
+  tests PaintersController
+
+  def setup
+    @controller.stubs(:resource_url).returns('/')
+    @controller.stubs(:collection_url).returns('/')
+  end
+
+  def test_expose_all_painters_as_instance_variable
+    Malarz.expects(:find).with(:all).returns([mock_painter])
+    get :index
+    assert_equal [mock_painter], assigns(:malarze)
+  end
+
+  def test_expose_the_resquested_painter_on_show
+    Malarz.expects(:find).with('42').returns(mock_painter)
+    get :show, :id => '42'
+    assert_equal mock_painter, assigns(:malarz)
+  end
+
+  def test_expose_a_new_painter
+    Malarz.expects(:new).returns(mock_painter)
+    get :new
+    assert_equal mock_painter, assigns(:malarz)
+  end
+
+  def test_expose_the_resquested_painter_on_edit
+    Malarz.expects(:find).with('42').returns(mock_painter)
+    get :edit, :id => '42'
+    assert_response :success
+    assert_equal mock_painter, assigns(:malarz)
+  end
+
+  def test_expose_a_newly_create_painter_when_saved_with_success
+    Malarz.expects(:new).with({'these' => 'params'}).returns(mock_painter(:save => true))
+    post :create, :malarz => {:these => 'params'}
+    assert_equal mock_painter, assigns(:malarz)
+  end
+
+  def test_update_the_requested_object
+    Malarz.expects(:find).with('42').returns(mock_painter)
+    mock_painter.expects(:update_attributes).with({'these' => 'params'}).returns(true)
+    put :update, :id => '42', :malarz => {:these => 'params'}
+    assert_equal mock_painter, assigns(:malarz)
+  end
+
+  def test_the_resquested_painter_is_destroyed
+    Malarz.expects(:find).with('42').returns(mock_painter)
+    mock_painter.expects(:destroy)
+    delete :destroy, :id => '42'
+    assert_equal mock_painter, assigns(:malarz)
+  end
+
+  protected
+    def mock_painter(stubs={})
+      @mock_painter ||= mock(stubs)
+    end
+end
+
@@ -0,0 +1,83 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class Address
+  def self.human_name; 'Address'; end
+end
+
+class AddressesController < InheritedResources::Base
+  protected
+    def interpolation_options
+      { :reference => 'Ocean Avenue' }
+    end
+end
+
+module Admin; end
+class Admin::AddressesController < InheritedResources::Base
+  protected
+    def interpolation_options
+      { :reference => 'Ocean Avenue' }
+    end
+end
+
+class FlashBaseHelpersTest < ActionController::TestCase
+  tests AddressesController
+
+  def setup
+    @request.accept = 'application/xml'
+  end
+
+  def test_success_flash_message_on_create_with_yml
+    Address.stubs(:new).returns(mock_address(:save => true))
+    @controller.stubs(:address_url)
+    post :create
+    assert_equal 'You created a new address close to <b>Ocean Avenue</b>.', flash[:notice]
+  end
+
+  def test_success_flash_message_on_create_with_namespaced_controller
+    @controller = Admin::AddressesController.new
+    Address.stubs(:new).returns(mock_address(:save => true))
+    @controller.stubs(:address_url)
+    post :create
+    assert_equal 'Admin, you created a new address close to <b>Ocean Avenue</b>.', flash[:notice]
+  end
+
+  def test_failure_flash_message_on_create_with_namespaced_controller_actions
+    @controller = Admin::AddressesController.new
+    Address.stubs(:new).returns(mock_address(:save => false))
+    @controller.stubs(:address_url)
+    post :create
+    assert_equal 'Admin error message.', flash[:error]
+  end
+
+  def test_inherited_success_flash_message_on_update_on_namespaced_controllers
+    @controller = Admin::AddressesController.new
+    Address.stubs(:find).returns(mock_address(:update_attributes => true))
+    put :update
+    assert_response :success
+    assert_equal 'Nice! Address was updated with success!', flash[:notice]
+  end
+
+  def test_success_flash_message_on_update
+    Address.stubs(:find).returns(mock_address(:update_attributes => true))
+    put :update
+    assert_response :success
+    assert_equal 'Nice! Address was updated with success!', flash[:notice]
+  end
+
+  def test_failure_flash_message_on_update
+    Address.stubs(:find).returns(mock_address(:update_attributes => false, :errors => []))
+    put :update
+    assert_equal 'Oh no! We could not update your address!', flash[:error]
+  end
+
+  def test_success_flash_message_on_destroy
+    Address.stubs(:find).returns(mock_address(:destroy => true))
+    delete :destroy
+    assert_equal 'Address was successfully destroyed.', flash[:notice]
+  end
+
+  protected
+    def mock_address(stubs={})
+      @mock_address ||= mock(stubs)
+    end
+end
@@ -0,0 +1,112 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class Tree
+  def self.human_name; 'Tree'; end
+end
+
+class TreesController < InheritedResources::Base
+  has_scope :color
+  has_scope :only_tall, :boolean => true, :only => :index
+  has_scope :shadown_range, :default => 10, :except => [ :index, :show, :destroy, :new ]
+  has_scope :root_type, :key => :root
+  has_scope :calculate_height, :default => proc {|c| c.session[:height] || 20 }, :only => :new
+end
+
+class HasScopeTest < ActionController::TestCase
+  tests TreesController
+
+  def setup
+    @controller.stubs(:resource_url).returns('/')
+    @controller.stubs(:collection_url).returns('/')
+  end
+
+  def test_boolean_scope_is_called_when_boolean_param_is_true
+    Tree.expects(:only_tall).with().returns(Tree).in_sequence
+    Tree.expects(:find).with(:all).returns([mock_tree]).in_sequence
+    get :index, :only_tall => 'true'
+    assert_equal([mock_tree], assigns(:trees))
+    assert_equal({ :only_tall => 'true' }, assigns(:current_scopes))
+  end
+
+  def test_boolean_scope_is_called_when_boolean_param_is_false
+    Tree.expects(:only_tall).never
+    Tree.expects(:find).with(:all).returns([mock_tree])
+    get :index, :only_tall => 'false'
+    assert_equal([mock_tree], assigns(:trees))
+    assert_equal({ :only_tall => 'false' }, assigns(:current_scopes))
+  end
+
+  def test_scope_is_called_only_on_index
+    Tree.expects(:only_tall).never
+    Tree.expects(:find).with('42').returns(mock_tree)
+    get :show, :only_tall => 'true', :id => '42'
+    assert_equal(mock_tree, assigns(:tree))
+    assert_equal({ }, assigns(:current_scopes))
+  end
+
+  def test_scope_is_called_except_on_index
+    Tree.expects(:shadown_range).with().never
+    Tree.expects(:find).with(:all).returns([mock_tree])
+    get :index, :shadown_range => 20
+    assert_equal([mock_tree], assigns(:trees))
+    assert_equal({ }, assigns(:current_scopes))
+  end
+
+  def test_scope_is_called_with_arguments
+    Tree.expects(:color).with('blue').returns(Tree).in_sequence
+    Tree.expects(:find).with(:all).returns([mock_tree]).in_sequence
+    get :index, :color => 'blue'
+    assert_equal([mock_tree], assigns(:trees))
+    assert_equal({ :color => 'blue' }, assigns(:current_scopes))
+  end
+
+  def test_multiple_scopes_are_called
+    Tree.expects(:only_tall).with().returns(Tree)
+    Tree.expects(:color).with('blue').returns(Tree)
+    Tree.expects(:find).with(:all).returns([mock_tree])
+    get :index, :color => 'blue', :only_tall => 'true'
+    assert_equal([mock_tree], assigns(:trees))
+    assert_equal({ :color => 'blue', :only_tall => 'true' }, assigns(:current_scopes))
+  end
+
+  def test_scope_is_called_with_default_value
+    Tree.expects(:shadown_range).with(10).returns(Tree).in_sequence
+    Tree.expects(:find).with('42').returns(mock_tree).in_sequence
+    get :edit, :id => '42'
+    assert_equal(mock_tree, assigns(:tree))
+    assert_equal({ :shadown_range => 10 }, assigns(:current_scopes))
+  end
+
+  def test_default_scope_value_can_be_overwritten
+    Tree.expects(:shadown_range).with('20').returns(Tree).in_sequence
+    Tree.expects(:find).with('42').returns(mock_tree).in_sequence
+    get :edit, :id => '42', :shadown_range => '20'
+    assert_equal(mock_tree, assigns(:tree))
+    assert_equal({ :shadown_range => '20' }, assigns(:current_scopes))
+  end
+
+  def test_scope_with_different_key
+    Tree.expects(:root_type).with('outside').returns(Tree).in_sequence
+    Tree.expects(:find).with('42').returns(mock_tree).in_sequence
+    get :show, :id => '42', :root => 'outside'
+    assert_equal(mock_tree, assigns(:tree))
+    assert_equal({ :root => 'outside' }, assigns(:current_scopes))
+  end
+
+  def test_scope_with_default_value_as_proc
+    session[:height] = 100
+    Tree.expects(:calculate_height).with(100).returns(Tree).in_sequence
+    Tree.expects(:new).returns(mock_tree).in_sequence
+    get :new
+    assert_equal(mock_tree, assigns(:tree))
+    assert_equal({ :calculate_height => 100 }, assigns(:current_scopes))
+   end
+
+  protected
+
+    def mock_tree(stubs={})
+      @mock_tree ||= mock(stubs)
+    end
+
+end
+
@@ -0,0 +1,108 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class Country
+end
+
+class State
+end
+
+class City
+  def self.human_name; 'City'; end
+end
+
+class CitiesController < InheritedResources::Base
+  belongs_to :country, :state
+end
+
+class NestedBelongsToTest < ActionController::TestCase
+  tests CitiesController
+
+  def setup
+    Country.expects(:find).with('13').returns(mock_country)
+    mock_country.expects(:states).returns(State)
+    State.expects(:find).with('37').returns(mock_state)
+    mock_state.expects(:cities).returns(City)
+
+    @controller.stubs(:resource_url).returns('/')
+    @controller.stubs(:collection_url).returns('/')
+  end
+
+  def test_assigns_country_and_state_and_city_on_create
+    City.expects(:find).with(:all).returns([mock_city])
+    get :index, :state_id => '37', :country_id => '13'
+
+    assert_equal mock_country, assigns(:country)
+    assert_equal mock_state, assigns(:state)
+    assert_equal [mock_city], assigns(:cities)
+  end
+
+  def test_assigns_country_and_state_and_city_on_show
+    City.expects(:find).with('42').returns(mock_city)
+    get :show, :id => '42', :state_id => '37', :country_id => '13'
+
+    assert_equal mock_country, assigns(:country)
+    assert_equal mock_state, assigns(:state)
+    assert_equal mock_city, assigns(:city)
+  end
+
+  def test_assigns_country_and_state_and_city_on_new
+    City.expects(:build).returns(mock_city)
+    get :new, :state_id => '37', :country_id => '13'
+
+    assert_equal mock_country, assigns(:country)
+    assert_equal mock_state, assigns(:state)
+    assert_equal mock_city, assigns(:city)
+  end
+
+  def test_assigns_country_and_state_and_city_on_edit
+    City.expects(:find).with('42').returns(mock_city)
+    get :edit, :id => '42', :state_id => '37', :country_id => '13'
+
+    assert_equal mock_country, assigns(:country)
+    assert_equal mock_state, assigns(:state)
+    assert_equal mock_city, assigns(:city)
+  end
+
+  def test_assigns_country_and_state_and_city_on_create
+    City.expects(:build).with({'these' => 'params'}).returns(mock_city)
+    mock_city.expects(:save).returns(true)
+    post :create, :state_id => '37', :country_id => '13', :city => {:these => 'params'}
+
+    assert_equal mock_country, assigns(:country)
+    assert_equal mock_state, assigns(:state)
+    assert_equal mock_city, assigns(:city)
+  end
+
+  def test_assigns_country_and_state_and_city_on_update
+    City.expects(:find).with('42').returns(mock_city)
+    mock_city.expects(:update_attributes).returns(true)
+    put :update, :id => '42', :state_id => '37', :country_id => '13', :city => {:these => 'params'}
+
+    assert_equal mock_country, assigns(:country)
+    assert_equal mock_state, assigns(:state)
+    assert_equal mock_city, assigns(:city)
+  end
+  
+  def test_assigns_country_and_state_and_city_on_destroy
+    City.expects(:find).with('42').returns(mock_city)
+    mock_city.expects(:destroy)
+    delete :destroy, :id => '42', :state_id => '37', :country_id => '13'
+
+    assert_equal mock_country, assigns(:country)
+    assert_equal mock_state, assigns(:state)
+    assert_equal mock_city, assigns(:city)
+  end
+
+  protected
+    def mock_country(stubs={})
+      @mock_country ||= mock(stubs)
+    end
+
+    def mock_state(stubs={})
+      @mock_state ||= mock(stubs)
+    end
+
+    def mock_city(stubs={})
+      @mock_city ||= mock(stubs)
+    end
+end
@@ -0,0 +1,164 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class Brands; end
+class Category; end
+
+class Product
+  def self.human_name; 'Product'; end
+end
+
+class ProductsController < InheritedResources::Base
+  belongs_to :brand, :category, :polymorphic => true, :optional => true
+end
+
+class OptionalTest < ActionController::TestCase
+  tests ProductsController
+
+  def setup
+    @controller.stubs(:resource_url).returns('/')
+    @controller.stubs(:collection_url).returns('/')
+  end
+
+  def test_expose_all_products_as_instance_variable_with_category
+    Category.expects(:find).with('37').returns(mock_category)
+    mock_category.expects(:products).returns(Product)
+    Product.expects(:find).with(:all).returns([mock_product])
+    get :index, :category_id => '37'
+    assert_equal mock_category, assigns(:category)
+    assert_equal [mock_product], assigns(:products)
+  end
+
+  def test_expose_all_products_as_instance_variable_without_category
+    Product.expects(:find).with(:all).returns([mock_product])
+    get :index
+    assert_equal nil, assigns(:category)
+    assert_equal [mock_product], assigns(:products)
+  end
+
+  def test_expose_the_resquested_product_with_category
+    Category.expects(:find).with('37').returns(mock_category)
+    mock_category.expects(:products).returns(Product)
+    Product.expects(:find).with('42').returns(mock_product)
+    get :show, :id => '42', :category_id => '37'
+    assert_equal mock_category, assigns(:category)
+    assert_equal mock_product, assigns(:product)
+  end
+
+  def test_expose_the_resquested_product_without_category
+    Product.expects(:find).with('42').returns(mock_product)
+    get :show, :id => '42'
+    assert_equal nil, assigns(:category)
+    assert_equal mock_product, assigns(:product)
+  end
+
+  def test_expose_a_new_product_with_category
+    Category.expects(:find).with('37').returns(mock_category)
+    mock_category.expects(:products).returns(Product)
+    Product.expects(:build).returns(mock_product)
+    get :new, :category_id => '37'
+    assert_equal mock_category, assigns(:category)
+    assert_equal mock_product, assigns(:product)
+  end
+
+  def test_expose_a_new_product_without_category
+    Product.expects(:new).returns(mock_product)
+    get :new
+    assert_equal nil, assigns(:category)
+    assert_equal mock_product, assigns(:product)
+  end
+
+  def test_expose_the_resquested_product_for_edition_with_category
+    Category.expects(:find).with('37').returns(mock_category)
+    mock_category.expects(:products).returns(Product)
+    Product.expects(:find).with('42').returns(mock_product)
+    get :edit, :id => '42', :category_id => '37'
+    assert_equal mock_category, assigns(:category)
+    assert_equal mock_product, assigns(:product)
+  end
+
+  def test_expose_the_resquested_product_for_edition_without_category
+    Product.expects(:find).with('42').returns(mock_product)
+    get :edit, :id => '42'
+    assert_equal nil, assigns(:category)
+    assert_equal mock_product, assigns(:product)
+  end
+
+  def test_expose_a_newly_create_product_with_category
+    Category.expects(:find).with('37').returns(mock_category)
+    mock_category.expects(:products).returns(Product)
+    Product.expects(:build).with({'these' => 'params'}).returns(mock_product(:save => true))
+    post :create, :category_id => '37', :product => {:these => 'params'}
+    assert_equal mock_category, assigns(:category)
+    assert_equal mock_product, assigns(:product)
+  end
+
+  def test_expose_a_newly_create_product_without_category
+    Product.expects(:new).with({'these' => 'params'}).returns(mock_product(:save => true))
+    post :create, :product => {:these => 'params'}
+    assert_equal nil, assigns(:category)
+    assert_equal mock_product, assigns(:product)
+  end
+
+  def test_update_the_requested_object_with_category
+    Category.expects(:find).with('37').returns(mock_category)
+    mock_category.expects(:products).returns(Product)
+    Product.expects(:find).with('42').returns(mock_product)
+    mock_product.expects(:update_attributes).with({'these' => 'params'}).returns(true)
+
+    put :update, :id => '42', :category_id => '37', :product => {:these => 'params'}
+    assert_equal mock_category, assigns(:category)
+    assert_equal mock_product, assigns(:product)
+  end
+
+  def test_update_the_requested_object_without_category
+    Product.expects(:find).with('42').returns(mock_product)
+    mock_product.expects(:update_attributes).with({'these' => 'params'}).returns(true)
+
+    put :update, :id => '42', :product => {:these => 'params'}
+    assert_equal nil, assigns(:category)
+    assert_equal mock_product, assigns(:product)
+  end
+
+  def test_the_resquested_product_is_destroyed_with_category
+    Category.expects(:find).with('37').returns(mock_category)
+    mock_category.expects(:products).returns(Product)
+    Product.expects(:find).with('42').returns(mock_product)
+    mock_product.expects(:destroy)
+    @controller.expects(:collection_url).returns('/')
+
+    delete :destroy, :id => '42', :category_id => '37'
+    assert_equal mock_category, assigns(:category)
+    assert_equal mock_product, assigns(:product)
+  end
+
+  def test_the_resquested_product_is_destroyed_without_category
+    Product.expects(:find).with('42').returns(mock_product)
+    mock_product.expects(:destroy)
+    @controller.expects(:collection_url).returns('/')
+
+    delete :destroy, :id => '42'
+    assert_equal nil, assigns(:category)
+    assert_equal mock_product, assigns(:product)
+  end
+
+  def test_polymorphic_helpers
+    Product.expects(:find).with(:all).returns([mock_product])
+    get :index
+
+    assert !@controller.send(:parent?)
+    assert_equal nil, assigns(:parent_type)
+    assert_equal nil, @controller.send(:parent_type)
+    assert_equal nil, @controller.send(:parent_class)
+    assert_equal nil, assigns(:category)
+    assert_equal nil, @controller.send(:parent)
+  end
+
+  protected
+    def mock_category(stubs={})
+      @mock_category ||= mock(stubs)
+    end
+
+    def mock_product(stubs={})
+      @mock_product ||= mock(stubs)
+    end
+end
@@ -0,0 +1,186 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class Factory; end
+class Company; end
+
+class Employee
+  def self.human_name; 'Employee'; end
+end
+
+class EmployeesController < InheritedResources::Base
+  belongs_to :factory, :company, :polymorphic => true
+end
+
+class PolymorphicFactoriesTest < ActionController::TestCase
+  tests EmployeesController
+
+  def setup
+    Factory.expects(:find).with('37').returns(mock_factory)
+    mock_factory.expects(:employees).returns(Employee)
+
+    @controller.stubs(:resource_url).returns('/')
+    @controller.stubs(:collection_url).returns('/')
+  end
+
+  def test_expose_all_employees_as_instance_variable_on_index
+    Employee.expects(:find).with(:all).returns([mock_employee])
+    get :index, :factory_id => '37'
+    assert_equal mock_factory, assigns(:factory)
+    assert_equal [mock_employee], assigns(:employees)
+  end
+
+  def test_expose_the_resquested_employee_on_show
+    Employee.expects(:find).with('42').returns(mock_employee)
+    get :show, :id => '42', :factory_id => '37'
+    assert_equal mock_factory, assigns(:factory)
+    assert_equal mock_employee, assigns(:employee)
+  end
+
+  def test_expose_a_new_employee_on_new
+    Employee.expects(:build).returns(mock_employee)
+    get :new, :factory_id => '37'
+    assert_equal mock_factory, assigns(:factory)
+    assert_equal mock_employee, assigns(:employee)
+  end
+
+  def test_expose_the_resquested_employee_on_edit
+    Employee.expects(:find).with('42').returns(mock_employee)
+    get :edit, :id => '42', :factory_id => '37'
+    assert_equal mock_factory, assigns(:factory)
+    assert_equal mock_employee, assigns(:employee)
+    assert_response :success
+  end
+
+  def test_expose_a_newly_create_employee_on_create
+    Employee.expects(:build).with({'these' => 'params'}).returns(mock_employee(:save => true))
+    post :create, :factory_id => '37', :employee => {:these => 'params'}
+    assert_equal mock_factory, assigns(:factory)
+    assert_equal mock_employee, assigns(:employee)
+  end
+
+  def test_update_the_requested_object_on_update
+    Employee.expects(:find).with('42').returns(mock_employee)
+    mock_employee.expects(:update_attributes).with({'these' => 'params'}).returns(true)
+    put :update, :id => '42', :factory_id => '37', :employee => {:these => 'params'}
+    assert_equal mock_factory, assigns(:factory)
+    assert_equal mock_employee, assigns(:employee)
+  end
+
+  def test_the_resquested_employee_is_destroyed_on_destroy
+    Employee.expects(:find).with('42').returns(mock_employee)
+    mock_employee.expects(:destroy)
+    delete :destroy, :id => '42', :factory_id => '37'
+    assert_equal mock_factory, assigns(:factory)
+    assert_equal mock_employee, assigns(:employee)
+  end
+
+  def test_polymorphic_helpers
+    mock_factory.stubs(:class).returns(Factory)
+
+    Employee.expects(:find).with(:all).returns([mock_employee])
+    get :index, :factory_id => '37'
+
+    assert @controller.send(:parent?)
+    assert_equal :factory, assigns(:parent_type)
+    assert_equal :factory, @controller.send(:parent_type)
+    assert_equal Factory, @controller.send(:parent_class)
+    assert_equal mock_factory, assigns(:factory)
+    assert_equal mock_factory, @controller.send(:parent)
+  end
+
+  protected
+    def mock_factory(stubs={})
+      @mock_factory ||= mock(stubs)
+    end
+
+    def mock_employee(stubs={})
+      @mock_employee ||= mock(stubs)
+    end
+end
+
+class PolymorphicCompanyTest < ActionController::TestCase
+  tests EmployeesController
+
+  def setup
+    Company.expects(:find).with('37').returns(mock_company)
+    mock_company.expects(:employees).returns(Employee)
+
+    @controller.stubs(:resource_url).returns('/')
+    @controller.stubs(:collection_url).returns('/')
+  end
+
+  def test_expose_all_employees_as_instance_variable_on_index
+    Employee.expects(:find).with(:all).returns([mock_employee])
+    get :index, :company_id => '37'
+    assert_equal mock_company, assigns(:company)
+    assert_equal [mock_employee], assigns(:employees)
+  end
+
+  def test_expose_the_resquested_employee_on_show
+    Employee.expects(:find).with('42').returns(mock_employee)
+    get :show, :id => '42', :company_id => '37'
+    assert_equal mock_company, assigns(:company)
+    assert_equal mock_employee, assigns(:employee)
+  end
+
+  def test_expose_a_new_employee_on_new
+    Employee.expects(:build).returns(mock_employee)
+    get :new, :company_id => '37'
+    assert_equal mock_company, assigns(:company)
+    assert_equal mock_employee, assigns(:employee)
+  end
+
+  def test_expose_the_resquested_employee_on_edit
+    Employee.expects(:find).with('42').returns(mock_employee)
+    get :edit, :id => '42', :company_id => '37'
+    assert_equal mock_company, assigns(:company)
+    assert_equal mock_employee, assigns(:employee)
+    assert_response :success
+  end
+
+  def test_expose_a_newly_create_employee_on_create
+    Employee.expects(:build).with({'these' => 'params'}).returns(mock_employee(:save => true))
+    post :create, :company_id => '37', :employee => {:these => 'params'}
+    assert_equal mock_company, assigns(:company)
+    assert_equal mock_employee, assigns(:employee)
+  end
+
+  def test_update_the_requested_object_on_update
+    Employee.expects(:find).with('42').returns(mock_employee)
+    mock_employee.expects(:update_attributes).with({'these' => 'params'}).returns(true)
+    put :update, :id => '42', :company_id => '37', :employee => {:these => 'params'}
+    assert_equal mock_company, assigns(:company)
+    assert_equal mock_employee, assigns(:employee)
+  end
+
+  def test_the_resquested_employee_is_destroyed_on_destroy
+    Employee.expects(:find).with('42').returns(mock_employee)
+    mock_employee.expects(:destroy)
+    delete :destroy, :id => '42', :company_id => '37'
+    assert_equal mock_company, assigns(:company)
+    assert_equal mock_employee, assigns(:employee)
+  end
+
+  def test_polymorphic_helpers
+    mock_company.stubs(:class).returns(Company)
+
+    Employee.expects(:find).with(:all).returns([mock_employee])
+    get :index, :company_id => '37'
+
+    assert @controller.send(:parent?)
+    assert_equal :company, assigns(:parent_type)
+    assert_equal :company, @controller.send(:parent_type)
+    assert_equal Company, @controller.send(:parent_class)
+    assert_equal mock_company, assigns(:company)
+    assert_equal mock_company, @controller.send(:parent)
+  end
+
+  protected
+    def mock_company(stubs={})
+      @mock_company ||= mock(stubs)
+    end
+
+    def mock_employee(stubs={})
+      @mock_employee ||= mock(stubs)
+    end
+end
@@ -0,0 +1,77 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class Machine;
+  def self.human_name; 'Machine'; end
+end
+
+class MachinesController < InheritedResources::Base
+  def create
+    create!{ complex_url(:create, true, true) }
+  end
+
+  def update
+    update!{ complex_url(:update, false, false) }
+  end
+
+  def destroy
+    destroy!{ complex_url(:destroy, true, false) }
+  end
+
+  protected
+    def complex_url(name, arg2, arg3)
+      'http://test.host/' + name.to_s
+    end
+end
+
+class RedirectToWithBlockTest < ActionController::TestCase
+  tests MachinesController
+
+  def test_redirect_to_the_given_url_on_create
+    Machine.stubs(:new).returns(mock_machine(:save => true))
+    @controller.expects(:resource_url).times(0)
+    post :create
+    assert_redirected_to 'http://test.host/create'
+  end
+
+  def test_redirect_to_the_given_url_on_update
+    Machine.stubs(:find).returns(mock_machine(:update_attributes => true))
+    @controller.expects(:resource_url).times(0)
+    put :update
+    assert_redirected_to 'http://test.host/update'
+  end
+
+  def test_redirect_to_the_given_url_on_destroy
+    Machine.stubs(:find).returns(mock_machine(:destroy => true))
+    @controller.expects(:collection_url).times(0)
+    delete :destroy
+    assert_redirected_to 'http://test.host/destroy'
+  end
+
+  protected
+    def mock_machine(stubs={})
+      @mock_machine ||= mock(stubs)
+    end
+end
+
+
+# Use this to test blocks with multiple arity in the future.
+class SuperMachinesController < InheritedResources::Base
+  defaults :resource_class => Machine
+
+  def create
+    create! do |arg1, arg2, arg3|
+      # nothing
+    end
+  end
+end
+
+class RedirectToArityTest < ActionController::TestCase
+  tests SuperMachinesController
+
+  def test_redirect_to_the_given_url_on_create
+    Machine.stubs(:new).returns(:anything)
+    assert_raise ScriptError, /arity/ do
+      post :create
+    end
+  end
+end
@@ -0,0 +1,314 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class Project
+  def to_html
+    'Generated HTML'
+  end
+
+  def to_xml
+    'Generated XML'
+  end
+
+  [:to_json, :to_rss, :to_rjs].each do |method|
+    undef_method method if respond_to? method
+  end
+end
+
+class ProjectsController < ActionController::Base
+  # Inherited respond_to definition is:
+  # respond_to :html
+  respond_to :html
+  respond_to :xml, :except => :edit
+  respond_to :rjs => :edit
+  respond_to :rss,  :only => 'index'
+  respond_to :json, :except => :index
+  respond_to :csv,  :except => :index
+
+  def index
+    respond_with(Project.new)
+  end
+
+  def respond_with_options
+    respond_with(Project.new, :to => [:xml, :json], :location => 'http://test.host/')
+  end
+
+  def skip_not_acceptable
+    respond_with(Project.new, :skip_not_acceptable => true)
+    render :text => 'Will not raise double render error.'
+  end
+
+  def respond_to_with_resource
+    respond_to(:with => Project.new)
+  end
+
+  def respond_to_with_resource_and_blocks
+    respond_to(:with => Project.new) do |format|
+      format.json { render :text => 'Render JSON' }
+      format.rss  { render :text => 'Render RSS' }
+    end
+  end
+
+  # If the user request Mime::ALL and we have a template called action.html.erb,
+  # the html template should be rendered *unless* html is specified inside the
+  # block. This tests exactly this case.
+  #
+  def respond_to_skip_default_template
+    respond_to(:with => Project.new) do |format|
+      format.html { render :text => 'Render HTML' }
+    end
+  end
+end
+
+class SuperProjectsController < ProjectsController
+end
+
+class RespondToUnitTest < ActionController::TestCase
+  tests ProjectsController
+
+  def setup
+    @formats   = @controller.formats_for_respond_to
+    @responder = ActionController::MimeResponds::Responder.new(@controller)
+  end
+
+  def test_respond_to_class_method_without_options
+    assert_nil @formats[:html][:only]
+    assert_nil @formats[:html][:except]
+  end
+
+  def test_respond_to_class_method_inheritance
+    assert_nil   @formats[:xml][:only]
+    assert_equal [:edit], @formats[:xml][:except]
+  end
+
+  def test_respond_to_class_method_with_implicit_only
+    assert_equal [:edit], @formats[:rjs][:only]
+    assert_nil   @formats[:rjs][:except]
+  end
+
+  def test_respond_to_class_method_with_explicit_only
+    assert_equal [:index], @formats[:rss][:only]
+    assert_nil   @formats[:rss][:except]
+  end
+
+  def test_respond_to_class_method_with_explicit_except
+    assert_nil   @formats[:json][:only]
+    assert_equal [:index], @formats[:json][:except]
+  end
+
+  def test_action_respond_to_format
+    @controller.action_name = 'index'
+    assert @responder.action_respond_to_format?('html')  # defined
+    assert @responder.action_respond_to_format?('xml')   # inherited
+    assert @responder.action_respond_to_format?('rss')   # explicit only
+    assert !@responder.action_respond_to_format?('json') # exception
+
+    @controller.action_name = 'edit'
+    assert !@responder.action_respond_to_format?('xml')  # inherited
+    assert @responder.action_respond_to_format?('rjs')   # implicit only
+    assert @responder.action_respond_to_format?('json')  # exception
+  end
+
+  def test_action_respond_to_format_with_additional_mimes
+    assert @responder.action_respond_to_format?('html', [:xml, :html, :json])
+    assert !@responder.action_respond_to_format?('html', [:xml, :rss, :json])
+
+    @controller.action_name = 'index'
+    assert @responder.action_respond_to_format?('html', [])
+    assert !@responder.action_respond_to_format?('json', [])
+  end
+
+  def test_clear_respond_to
+    @controller = SuperProjectsController.new
+    @controller.request  = ActionController::TestRequest.new
+
+    @controller.action_name = 'index'
+    @responder = ActionController::MimeResponds::Responder.new(@controller)
+
+    # Those responses are inherited from ProjectsController
+    assert @responder.action_respond_to_format?('html')  # defined
+    assert @responder.action_respond_to_format?('xml')   # inherited
+    assert @responder.action_respond_to_format?('rss')   # explicit only
+
+    # Let's clear respond_to definitions
+    SuperProjectsController.send(:clear_respond_to!)
+
+    assert !@responder.action_respond_to_format?('html')
+    assert !@responder.action_respond_to_format?('xml')
+    assert !@responder.action_respond_to_format?('rss')
+  end
+
+  def test_respond_except_any_does_not_respond_to_mime_all
+    prepare_responder_to_respond!
+
+    @responder.respond_except_any
+    assert !@performed
+
+    @responder.respond
+    assert @performed
+  end
+
+  def test_respond_any_responds_to_mime_all
+    prepare_responder_to_respond!
+
+    @responder.respond_any
+    assert @performed
+  end
+
+  def test_respond_any_responds_only_to_all
+    prepare_responder_to_respond!('text/html')
+
+    @responder.respond_any
+    assert !@performed
+  end
+
+  def test_responder_prioritize
+    prepare_responder_to_respond!
+    assert_equal [Mime::HTML, Mime::XML], @responder.order
+
+    @responder.prioritize(:xml)
+    assert_equal [Mime::XML, Mime::HTML], @responder.order
+
+    @responder.prioritize(:js)
+    assert_equal [Mime::XML, Mime::HTML], @responder.order
+  end
+ 
+  protected 
+    def prepare_responder_to_respond!(content_type='*/*')
+      @controller.request  = @request  = ActionController::TestRequest.new
+      @controller.response = @response = ActionController::TestResponse.new
+
+      @request.accept = content_type
+      @responder  = ActionController::MimeResponds::Responder.new(@controller)
+      @performed = false
+
+      # Mock template
+      template = mock()
+      @response.stubs(:template).returns(template)
+      template.stubs(:template_format=).returns(true)
+
+      respond_to_declaration = proc { |format|
+        format.html { @performed = true }
+        format.xml  { }
+      }
+
+      respond_to_declaration.call(@responder)
+    end
+end
+
+class RespondToFunctionalTest < ActionController::TestCase
+  tests ProjectsController
+
+  def test_respond_with_layout_rendering
+    @request.accept = 'text/html'
+    get :index
+    assert_equal 'Index HTML', @response.body.strip
+  end
+
+  def test_respond_with_calls_to_format_on_resource
+    @request.accept = 'application/xml'
+    get :index
+    assert_equal 'Generated XML', @response.body.strip
+  end
+
+  def test_respond_with_inherits_format
+    @request.accept = 'application/xml'
+    get :index
+    assert_equal 'Generated XML', @response.body.strip
+  end
+
+  def test_respond_with_renders_status_not_acceptable_if_mime_type_is_not_registered
+    @request.accept = 'text/csv'
+    get :index
+    assert_equal '406 Not Acceptable', @response.status
+  end
+
+  def test_respond_with_renders_not_found_when_mime_type_is_valid_but_could_not_render
+    @request.accept = 'application/rss+xml'
+    get :index
+    assert_equal '404 Not Found', @response.status
+  end
+
+  def test_respond_to_all
+    @request.accept = '*/*'
+    get :index
+    assert_equal 'Index HTML', @response.body.strip
+  end
+
+  def test_default_template_is_not_rendered_if_template_format_is_not_accepted
+    @controller.stubs(:default_template_format).returns(:json)
+    @request.accept = '*/*'
+    get :index
+    assert_equal '406 Not Acceptable', @response.status
+  end
+
+  def test_respond_with_sets_content_type_properly
+    @request.accept = 'text/html'
+    get :index
+    assert_equal 'text/html', @response.content_type
+    assert_equal :html, @response.template.template_format
+
+    @request.accept = 'application/xml'
+    get :index
+    assert_equal 'application/xml', @response.content_type
+    assert_equal :xml, @response.template.template_format
+  end
+
+  def test_respond_with_when_to_is_given_as_option
+    @request.accept = 'text/html'
+    get :respond_with_options
+    assert_equal '406 Not Acceptable', @response.status
+
+    @request.accept = 'application/xml'
+    get :respond_with_options
+    assert_equal 'Generated XML', @response.body.strip
+  end
+
+  def test_respond_with_forwads_extra_options_to_render
+    @request.accept = 'application/xml'
+    get :respond_with_options
+    assert_equal 'Generated XML', @response.body.strip
+    assert_equal 'http://test.host/', @response.headers['Location']
+  end
+
+  def test_respond_with_skips_head_when_skip_not_acceptable_is_given
+    @request.accept = 'application/rss+xml'
+    get :skip_not_acceptable
+    assert_equal 'Will not raise double render error.', @response.body.strip
+  end
+
+  def test_respond_to_when_a_resource_is_given_as_option
+    @request.accept = 'text/html'
+    get :respond_to_with_resource
+    assert_equal 'RespondTo HTML', @response.body.strip
+
+    @request.accept = 'application/xml'
+    get :respond_to_with_resource
+    assert_equal 'Generated XML', @response.body.strip
+
+    @request.accept = 'application/json'
+    get :respond_to_with_resource
+    assert_equal '404 Not Found', @response.status
+
+    @request.accept = 'application/rss+xml'
+    get :respond_to_with_resource
+    assert_equal '406 Not Acceptable', @response.status
+  end
+
+  def test_respond_to_overwrite_class_method_definition
+    @request.accept = 'application/rss+xml'
+    get :respond_to_with_resource_and_blocks
+    assert_equal 'Render RSS', @response.body.strip
+  end
+
+  def test_respond_to_fallback_to_first_block_when_mime_type_is_all
+    @request.accept = '*/*'
+    get :respond_to_with_resource_and_blocks
+    assert_equal 'Render JSON', @response.body.strip
+  end
+
+  def test_respond_to_skip_default_template_when_it_is_in_block
+    @request.accept = '*/*'
+    get :respond_to_skip_default_template
+    assert_equal 'Render HTML', @response.body.strip
+  end
+end
@@ -0,0 +1,83 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+# This test file is instead to test the how controller flow and actions
+# using a belongs_to association. This is done using mocks a la rspec.
+#
+class Store
+end
+
+class Manager
+  def self.human_name; 'Manager'; end
+end
+
+class ManagersController < InheritedResources::Base
+  belongs_to :store, :singleton => true
+end
+
+class SingletonTest < ActionController::TestCase
+  tests ManagersController
+
+  def setup
+    @controller.stubs(:resource_url).returns('/')
+    @controller.stubs(:collection_url).returns('/')
+  end
+
+  def test_expose_the_resquested_manager_on_show
+    Store.expects(:find).with('37').returns(mock_store)
+    mock_store.expects(:manager).returns(mock_manager)
+    get :show, :store_id => '37'
+    assert_equal mock_store, assigns(:store)
+    assert_equal mock_manager, assigns(:manager)
+  end
+
+  def test_expose_a_new_manager_on_new
+    Store.expects(:find).with('37').returns(mock_store)
+    mock_store.expects(:build_manager).returns(mock_manager)
+    get :new, :store_id => '37'
+    assert_equal mock_store, assigns(:store)
+    assert_equal mock_manager, assigns(:manager)
+  end
+
+  def test_expose_the_resquested_manager_on_edit
+    Store.expects(:find).with('37').returns(mock_store)
+    mock_store.expects(:manager).returns(mock_manager)
+    get :edit, :store_id => '37'
+    assert_equal mock_store, assigns(:store)
+    assert_equal mock_manager, assigns(:manager)
+    assert_response :success
+  end
+
+  def test_expose_a_newly_create_manager_on_create
+    Store.expects(:find).with('37').returns(mock_store)
+    mock_store.expects(:build_manager).with({'these' => 'params'}).returns(mock_manager(:save => true))
+    post :create, :store_id => '37', :manager => {:these => 'params'}
+    assert_equal mock_store, assigns(:store)
+    assert_equal mock_manager, assigns(:manager)
+  end
+
+  def test_update_the_requested_object_on_update
+    Store.expects(:find).with('37').returns(mock_store(:manager => mock_manager))
+    mock_manager.expects(:update_attributes).with({'these' => 'params'}).returns(true)
+    put :update, :store_id => '37', :manager => {:these => 'params'}
+    assert_equal mock_store, assigns(:store)
+    assert_equal mock_manager, assigns(:manager)
+  end
+
+  def test_the_resquested_manager_is_destroyed_on_destroy
+    Store.expects(:find).with('37').returns(mock_store)
+    mock_store.expects(:manager).returns(mock_manager)
+    mock_manager.expects(:destroy)
+    delete :destroy, :store_id => '37'
+    assert_equal mock_store, assigns(:store)
+    assert_equal mock_manager, assigns(:manager)
+  end
+
+  protected
+    def mock_store(stubs={})
+      @mock_store ||= mock(stubs)
+    end
+
+    def mock_manager(stubs={})
+      @mock_manager ||= mock(stubs)
+    end
+end
@@ -0,0 +1,27 @@
+require 'test/unit'
+require 'rubygems'
+require 'ruby-debug'
+require 'mocha'
+
+ENV["RAILS_ENV"] = "test"
+RAILS_ROOT = "anywhere"
+
+require 'active_support'
+require 'action_controller'
+require 'action_controller/test_case'
+require 'action_controller/test_process'
+
+I18n.load_path << File.join(File.dirname(__FILE__), 'locales', 'en.yml')
+I18n.reload!
+
+class ApplicationController < ActionController::Base; end
+
+# Add IR to load path and load the main file
+ActiveSupport::Dependencies.load_paths << File.expand_path(File.dirname(__FILE__) + '/../lib')
+require_dependency 'inherited_resources'
+
+ActionController::Base.view_paths = File.join(File.dirname(__FILE__), 'views')
+
+ActionController::Routing::Routes.draw do |map|
+  map.connect ':controller/:action/:id'
+end
@@ -0,0 +1,471 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class Universe; end
+class UniversesController < InheritedResources::Base
+  defaults :singleton => true, :route_instance_name => 'universum'
+end
+
+class House; end
+class HousesController < InheritedResources::Base
+end
+
+class Backpack; end
+module Admin; end
+class Admin::BackpacksController < InheritedResources::Base
+  defaults :route_collection_name => 'tour_backpacks'
+end
+
+class Table; end
+class TablesController < InheritedResources::Base
+  belongs_to :house
+end
+
+class RoomsController < InheritedResources::Base
+  belongs_to :house, :route_name => 'big_house'
+end
+
+class ChairsController < InheritedResources::Base
+  belongs_to :house do
+    belongs_to :table
+  end
+end
+
+class OwnersController < InheritedResources::Base
+  singleton_belongs_to :house
+end
+
+class Bed; end
+class BedsController < InheritedResources::Base
+  optional_belongs_to :house, :building
+end
+
+class Desk; end
+module Admin
+  class DesksController < InheritedResources::Base
+    optional_belongs_to :house
+  end
+end
+
+class Dish; end
+class DishesController < InheritedResources::Base
+  belongs_to :house do
+    polymorphic_belongs_to :table, :kitchen
+  end
+end
+
+class Center; end
+class CentersController < InheritedResources::Base
+  acts_as_singleton!
+
+  belongs_to :house do
+    belongs_to :table, :kitchen, :polymorphic => true
+  end
+end
+
+# Create a TestHelper module with some helpers
+class UrlHelpersTest < ActiveSupport::TestCase
+
+  def test_url_helpers_on_simple_inherited_resource
+    controller = HousesController.new
+    controller.instance_variable_set('@house', :house)
+
+    [:url, :path].each do |path_or_url|
+      controller.expects("houses_#{path_or_url}").with({}).once
+      controller.send("collection_#{path_or_url}")
+
+      controller.expects("house_#{path_or_url}").with(:house, {}).once
+      controller.send("resource_#{path_or_url}")
+
+      controller.expects("new_house_#{path_or_url}").with({}).once
+      controller.send("new_resource_#{path_or_url}")
+
+      controller.expects("edit_house_#{path_or_url}").with(:house, {}).once
+      controller.send("edit_resource_#{path_or_url}")
+
+      # With arg
+      controller.expects("house_#{path_or_url}").with(:arg, {}).once
+      controller.send("resource_#{path_or_url}", :arg)
+
+      controller.expects("house_#{path_or_url}").with(:arg, {}).once
+      controller.send("resource_#{path_or_url}", :arg)
+
+      # With options
+      controller.expects("house_#{path_or_url}").with(:arg, :page => 1).once
+      controller.send("resource_#{path_or_url}", :arg, :page => 1)
+    end
+  end
+
+  def test_url_helpers_on_simple_inherited_namespaced_resource
+    controller = Admin::BackpacksController.new
+    controller.instance_variable_set('@backpack', :backpack)
+
+    assert_equal 'admin', controller.class.resources_configuration[:self][:route_prefix]
+
+    [:url, :path].each do |path_or_url|
+      controller.expects("admin_tour_backpacks_#{path_or_url}").with({}).once
+      controller.send("collection_#{path_or_url}")
+
+      controller.expects("admin_backpack_#{path_or_url}").with(:backpack, {}).once
+      controller.send("resource_#{path_or_url}")
+
+      controller.expects("new_admin_backpack_#{path_or_url}").with({}).once
+      controller.send("new_resource_#{path_or_url}")
+
+      controller.expects("edit_admin_backpack_#{path_or_url}").with(:backpack, {}).once
+      controller.send("edit_resource_#{path_or_url}")
+
+      # With arg
+      controller.expects("admin_backpack_#{path_or_url}").with(:arg, {}).once
+      controller.send("resource_#{path_or_url}", :arg)
+
+      controller.expects("admin_backpack_#{path_or_url}").with(:arg, {}).once
+      controller.send("resource_#{path_or_url}", :arg)
+
+      # With options
+      controller.expects("admin_backpack_#{path_or_url}").with(:arg, :page => 1).once
+      controller.send("resource_#{path_or_url}", :arg, :page => 1)
+    end
+  end
+
+  def test_url_helpers_on_simple_inherited_singleton_resource
+    controller = UniversesController.new
+    controller.instance_variable_set('@universe', :universe)
+
+    [:url, :path].each do |path_or_url|
+      controller.expects("root_#{path_or_url}").with({}).once
+      controller.send("collection_#{path_or_url}")
+
+      controller.expects("universum_#{path_or_url}").with({}).once
+      controller.send("resource_#{path_or_url}")
+
+      controller.expects("new_universum_#{path_or_url}").with({}).once
+      controller.send("new_resource_#{path_or_url}")
+
+      controller.expects("edit_universum_#{path_or_url}").with({}).once
+      controller.send("edit_resource_#{path_or_url}")
+
+      # With options
+      # Also tests that argument sent are not used
+      controller.expects("universum_#{path_or_url}").with(:page => 1).once
+      controller.send("resource_#{path_or_url}", :arg, :page => 1)
+    end
+  end
+
+  def test_url_helpers_on_belongs_to
+    controller = TablesController.new
+    controller.instance_variable_set('@house', :house)
+    controller.instance_variable_set('@table', :table)
+
+    [:url, :path].each do |path_or_url|
+      controller.expects("house_tables_#{path_or_url}").with(:house, {}).once
+      controller.send("collection_#{path_or_url}")
+
+      controller.expects("house_table_#{path_or_url}").with(:house, :table, {}).once
+      controller.send("resource_#{path_or_url}")
+
+      controller.expects("new_house_table_#{path_or_url}").with(:house, {}).once
+      controller.send("new_resource_#{path_or_url}")
+
+      controller.expects("edit_house_table_#{path_or_url}").with(:house, :table, {}).once
+      controller.send("edit_resource_#{path_or_url}")
+
+      # With arg
+      controller.expects("house_table_#{path_or_url}").with(:house, :arg, {}).once
+      controller.send("resource_#{path_or_url}", :arg)
+
+      controller.expects("edit_house_table_#{path_or_url}").with(:house, :arg, {}).once
+      controller.send("edit_resource_#{path_or_url}", :arg)
+
+      # With options
+      controller.expects("house_table_#{path_or_url}").with(:house, :arg, :page => 1).once
+      controller.send("resource_#{path_or_url}", :arg, :page => 1)
+    end
+  end
+
+  def test_url_helpers_on_not_default_belongs_to
+    controller = RoomsController.new
+    controller.instance_variable_set('@house', :house)
+    controller.instance_variable_set('@room', :room)
+
+    [:url, :path].each do |path_or_url|
+      controller.expects("big_house_rooms_#{path_or_url}").with(:house, {}).once
+      controller.send("collection_#{path_or_url}")
+
+      controller.expects("big_house_room_#{path_or_url}").with(:house, :room, {}).once
+      controller.send("resource_#{path_or_url}")
+
+      controller.expects("new_big_house_room_#{path_or_url}").with(:house, {}).once
+      controller.send("new_resource_#{path_or_url}")
+
+      controller.expects("edit_big_house_room_#{path_or_url}").with(:house, :room, {}).once
+      controller.send("edit_resource_#{path_or_url}")
+
+      # With args
+      controller.expects("big_house_room_#{path_or_url}").with(:house, :arg, {}).once
+      controller.send("resource_#{path_or_url}", :arg)
+
+      controller.expects("edit_big_house_room_#{path_or_url}").with(:house, :arg, {}).once
+      controller.send("edit_resource_#{path_or_url}", :arg)
+
+      # With options
+      controller.expects("big_house_room_#{path_or_url}").with(:house, :arg, :page => 1).once
+      controller.send("resource_#{path_or_url}", :arg, :page => 1)
+    end
+  end
+
+  def test_url_helpers_on_nested_belongs_to
+    controller = ChairsController.new
+    controller.instance_variable_set('@house', :house)
+    controller.instance_variable_set('@table', :table)
+    controller.instance_variable_set('@chair', :chair)
+
+    [:url, :path].each do |path_or_url|
+      controller.expects("house_table_chairs_#{path_or_url}").with(:house, :table, {}).once
+      controller.send("collection_#{path_or_url}")
+
+      controller.expects("house_table_chair_#{path_or_url}").with(:house, :table, :chair, {}).once
+      controller.send("resource_#{path_or_url}")
+
+      controller.expects("new_house_table_chair_#{path_or_url}").with(:house, :table, {}).once
+      controller.send("new_resource_#{path_or_url}")
+
+      controller.expects("edit_house_table_chair_#{path_or_url}").with(:house, :table, :chair, {}).once
+      controller.send("edit_resource_#{path_or_url}")
+
+      # With args
+      controller.expects("edit_house_table_chair_#{path_or_url}").with(:house, :table, :arg, {}).once
+      controller.send("edit_resource_#{path_or_url}", :arg)
+
+      controller.expects("house_table_chair_#{path_or_url}").with(:house, :table, :arg, {}).once
+      controller.send("resource_#{path_or_url}", :arg)
+
+      # With options
+      controller.expects("edit_house_table_chair_#{path_or_url}").with(:house, :table, :arg, :page => 1).once
+      controller.send("edit_resource_#{path_or_url}", :arg, :page => 1)
+    end
+  end
+
+  def test_url_helpers_on_singletons_with_belongs_to
+    controller = OwnersController.new
+    controller.instance_variable_set('@house', :house)
+    controller.instance_variable_set('@owner', :owner)
+
+    [:url, :path].each do |path_or_url|
+      controller.expects("house_#{path_or_url}").with(:house, {}).once
+      controller.send("collection_#{path_or_url}")
+
+      controller.expects("house_owner_#{path_or_url}").with(:house, {}).once
+      controller.send("resource_#{path_or_url}")
+
+      controller.expects("new_house_owner_#{path_or_url}").with(:house, {}).once
+      controller.send("new_resource_#{path_or_url}")
+
+      controller.expects("edit_house_owner_#{path_or_url}").with(:house, {}).once
+      controller.send("edit_resource_#{path_or_url}")
+
+      # With options
+      # Also tests that argument sent are not used
+      controller.expects("house_owner_#{path_or_url}").with(:house, :page => 1).once
+      controller.send("resource_#{path_or_url}", :arg, :page => 1)
+    end
+  end
+
+  def test_url_helpers_on_polymorphic_belongs_to
+    house = House.new
+    bed   = Bed.new
+    
+    new_bed = Bed.new
+    Bed.stubs(:new).returns(new_bed)
+    new_bed.stubs(:new_record?).returns(true)
+
+    controller = BedsController.new
+    controller.instance_variable_set('@parent_type', :house)
+    controller.instance_variable_set('@house', house)
+    controller.instance_variable_set('@bed', bed)
+
+    [:url, :path].each do |path_or_url|
+      controller.expects("house_beds_#{path_or_url}").with(house).once
+      controller.send("collection_#{path_or_url}")
+
+      controller.expects("house_bed_#{path_or_url}").with(house, bed).once
+      controller.send("resource_#{path_or_url}")
+
+      controller.expects("new_house_bed_#{path_or_url}").with(house).once
+      controller.send("new_resource_#{path_or_url}")
+
+      controller.expects("edit_house_bed_#{path_or_url}").with(house, bed).once
+      controller.send("edit_resource_#{path_or_url}")
+    end
+
+    # With options
+    controller.expects("house_bed_url").with(house, bed, :page => 1).once
+    controller.send("resource_url", :page => 1)
+
+    # With args
+    controller.expects("polymorphic_url").with([:arg, new_bed], {}).once
+    controller.send("collection_url", :arg)
+
+    controller.expects("polymorphic_url").with([house, :arg], {}).once
+    controller.send("resource_url", :arg)
+
+    controller.expects("edit_polymorphic_url").with([house, :arg], {}).once
+    controller.send("edit_resource_url", :arg)
+  end
+
+  def test_url_helpers_on_namespaced_polymorphic_belongs_to
+    house = House.new
+    desk  = Desk.new
+
+    new_desk = Desk.new
+    Desk.stubs(:new).returns(new_desk)
+    new_desk.stubs(:new_record?).returns(true)
+
+    controller = Admin::DesksController.new
+    controller.instance_variable_set('@parent_type', :house)
+    controller.instance_variable_set('@house', house)
+    controller.instance_variable_set('@desk', desk)
+
+    [:url, :path].each do |path_or_url|
+      controller.expects("admin_house_desks_#{path_or_url}").with(house).once
+      controller.send("collection_#{path_or_url}")
+
+      controller.expects("admin_house_desk_#{path_or_url}").with(house, desk).once
+      controller.send("resource_#{path_or_url}")
+
+      controller.expects("new_admin_house_desk_#{path_or_url}").with(house).once
+      controller.send("new_resource_#{path_or_url}")
+
+      controller.expects("edit_admin_house_desk_#{path_or_url}").with(house, desk).once
+      controller.send("edit_resource_#{path_or_url}")
+    end
+
+    # With options
+    controller.expects("admin_house_desk_url").with(house, desk, :page => 1).once
+    controller.send("resource_url", :page => 1)
+
+    # With args
+    controller.expects("polymorphic_url").with(['admin', :arg, new_desk], {}).once
+    controller.send("collection_url", :arg)
+
+    controller.expects("polymorphic_url").with(['admin', house, :arg], {}).once
+    controller.send("resource_url", :arg)
+
+    controller.expects("edit_polymorphic_url").with(['admin', house, :arg], {}).once
+    controller.send("edit_resource_url", :arg)
+  end
+
+  def test_url_helpers_on_nested_polymorphic_belongs_to
+    house = House.new
+    table = Table.new
+    dish  = Dish.new
+
+    new_dish = Dish.new
+    Dish.stubs(:new).returns(new_dish)
+    new_dish.stubs(:new_record?).returns(true)
+
+    controller = DishesController.new
+    controller.instance_variable_set('@parent_type', :table)
+    controller.instance_variable_set('@house', house)
+    controller.instance_variable_set('@table', table)
+    controller.instance_variable_set('@dish', dish)
+
+    [:url, :path].each do |path_or_url|
+      controller.expects("house_table_dishes_#{path_or_url}").with(house, table).once
+      controller.send("collection_#{path_or_url}")
+
+      controller.expects("house_table_dish_#{path_or_url}").with(house, table, dish).once
+      controller.send("resource_#{path_or_url}")
+
+      controller.expects("new_house_table_dish_#{path_or_url}").with(house, table).once
+      controller.send("new_resource_#{path_or_url}")
+
+      controller.expects("edit_house_table_dish_#{path_or_url}").with(house, table, dish).once
+      controller.send("edit_resource_#{path_or_url}")
+    end
+
+    # With options
+    controller.expects("house_table_dish_url").with(house, table, dish, :page => 1).once
+    controller.send("resource_url", :page => 1)
+
+    # With args
+    controller.expects("polymorphic_url").with([house, table, :arg], {}).once
+    controller.send("resource_url", :arg)
+
+    controller.expects("edit_polymorphic_url").with([house, table, :arg], {}).once
+    controller.send("edit_resource_url", :arg)
+  end
+
+  def test_url_helpers_on_singleton_nested_polymorphic_belongs_to
+    # This must not be usefull in singleton controllers...
+    # Center.new
+    house = House.new
+    table = Table.new
+
+    controller = CentersController.new
+    controller.instance_variable_set('@parent_type', :table)
+    controller.instance_variable_set('@house', house)
+    controller.instance_variable_set('@table', table)
+
+    # This must not be useful in singleton controllers...
+    # controller.instance_variable_set('@center', :center)
+
+    [:url, :path].each do |path_or_url|
+      controller.expects("house_table_#{path_or_url}").with(house, table).once
+      controller.send("collection_#{path_or_url}")
+
+      controller.expects("house_table_center_#{path_or_url}").with(house, table).once
+      controller.send("resource_#{path_or_url}")
+
+      controller.expects("new_house_table_center_#{path_or_url}").with(house, table).once
+      controller.send("new_resource_#{path_or_url}")
+
+      controller.expects("edit_house_table_center_#{path_or_url}").with(house, table).once
+      controller.send("edit_resource_#{path_or_url}")
+    end
+
+    # With options
+    controller.expects("house_table_center_url").with(house, table, :page => 1)
+    controller.send("resource_url", :page => 1)
+
+    # With args
+    controller.expects("polymorphic_url").with([house, table, :center], {}).once
+    controller.send("resource_url", :arg)
+  end
+
+  def test_url_helpers_on_optional_polymorphic_belongs_to
+    bed   = Bed.new
+    new_bed = Bed.new
+    Bed.stubs(:new).returns(new_bed)
+    new_bed.stubs(:new_record?).returns(true)
+
+    controller = BedsController.new
+    controller.instance_variable_set('@parent_type', nil)
+    controller.instance_variable_set('@bed', bed)
+
+    [:url, :path].each do |path_or_url|
+      controller.expects("beds_#{path_or_url}").with().once
+      controller.send("collection_#{path_or_url}")
+
+      controller.expects("bed_#{path_or_url}").with(bed).once
+      controller.send("resource_#{path_or_url}")
+
+      controller.expects("new_bed_#{path_or_url}").with().once
+      controller.send("new_resource_#{path_or_url}")
+
+      controller.expects("edit_bed_#{path_or_url}").with(bed).once
+      controller.send("edit_resource_#{path_or_url}")
+    end
+
+    # With options
+    controller.expects("bed_url").with(bed, :page => 1).once
+    controller.send("resource_url", :page => 1)
+
+    # With args
+    controller.expects("polymorphic_url").with([:arg], {}).once
+    controller.send("resource_url", :arg)
+
+    controller.expects("edit_polymorphic_url").with([:arg], {}).once
+    controller.send("edit_resource_url", :arg)
+  end
+
+end
@@ -0,0 +1,104 @@		@@ -0,0 +1,104 @@
	1	+--- !ruby/object:Gem::Specification
	2	+name: josevalim-inherited_resources
	3	+version: !ruby/object:Gem::Version
	4	+ version: 0.8.5
	5	+platform: ruby
	6	+authors:
	7	+- "Jos\xC3\xA9 Valim"
	8	+autorequire:
	9	+bindir: bin
	10	+cert_chain: []
	11	+
	12	+date: 2009-07-24 00:00:00 -04:00
	13	+default_executable:
	14	+dependencies: []
	15	+
	16	+description: Inherited Resources speeds up development by making your controllers inherit all restful actions so you just have to focus on what is important.
	17	+email: jose.valim@gmail.com
	18	+executables: []
	19	+
	20	+extensions: []
	21	+
	22	+extra_rdoc_files:
	23	+- README
	24	+files:
	25	+- CHANGELOG
	26	+- MIT-LICENSE
	27	+- README
	28	+- Rakefile
	29	+- VERSION
	30	+- lib/inherited_resources.rb
	31	+- lib/inherited_resources/actions.rb
	32	+- lib/inherited_resources/base.rb
	33	+- lib/inherited_resources/base_helpers.rb
	34	+- lib/inherited_resources/belongs_to_helpers.rb
	35	+- lib/inherited_resources/class_methods.rb
	36	+- lib/inherited_resources/dumb_responder.rb
	37	+- lib/inherited_resources/has_scope_helpers.rb
	38	+- lib/inherited_resources/polymorphic_helpers.rb
	39	+- lib/inherited_resources/respond_to.rb
	40	+- lib/inherited_resources/singleton_helpers.rb
	41	+- lib/inherited_resources/url_helpers.rb
	42	+- test/respond_to_test.rb
	43	+- test/customized_belongs_to_test.rb
	44	+- test/nested_belongs_to_test.rb
	45	+- test/base_test.rb
	46	+- test/redirect_to_test.rb
	47	+- test/has_scope_test.rb
	48	+- test/class_methods_test.rb
	49	+- test/aliases_test.rb
	50	+- test/flash_test.rb
	51	+- test/url_helpers_test.rb
	52	+- test/base_helpers_test.rb
	53	+- test/belongs_to_test.rb
	54	+- test/polymorphic_test.rb
	55	+- test/defaults_test.rb
	56	+- test/singleton_test.rb
	57	+- test/optional_belongs_to_test.rb
	58	+- test/test_helper.rb
	59	+has_rdoc: true
	60	+homepage: http://github.com/josevalim/inherited_resources
	61	+licenses: []
	62	+
	63	+post_install_message:
	64	+rdoc_options:
	65	+- --charset=UTF-8
	66	+require_paths:
	67	+- lib
	68	+required_ruby_version: !ruby/object:Gem::Requirement
	69	+ requirements:
	70	+ - - ">="
	71	+ - !ruby/object:Gem::Version
	72	+ version: "0"
	73	+ version:
	74	+required_rubygems_version: !ruby/object:Gem::Requirement
	75	+ requirements:
	76	+ - - ">="
	77	+ - !ruby/object:Gem::Version
	78	+ version: "0"
	79	+ version:
	80	+requirements: []
	81	+
	82	+rubyforge_project: inherited_resources
	83	+rubygems_version: 1.3.4
	84	+signing_key:
	85	+specification_version: 3
	86	+summary: Inherited Resources speeds up development by making your controllers inherit all restful actions so you just have to focus on what is important.
	87	+test_files:
	88	+- test/respond_to_test.rb
	89	+- test/customized_belongs_to_test.rb
	90	+- test/nested_belongs_to_test.rb
	91	+- test/base_test.rb
	92	+- test/redirect_to_test.rb
	93	+- test/has_scope_test.rb
	94	+- test/class_methods_test.rb
	95	+- test/aliases_test.rb
	96	+- test/flash_test.rb
	97	+- test/url_helpers_test.rb
	98	+- test/base_helpers_test.rb
	99	+- test/belongs_to_test.rb
	100	+- test/polymorphic_test.rb
	101	+- test/defaults_test.rb
	102	+- test/singleton_test.rb
	103	+- test/optional_belongs_to_test.rb
	104	+- test/test_helper.rb
@@ -0,0 +1,95 @@		@@ -0,0 +1,95 @@
	1	+# Version 0.8
	2	+
	3	+* Fixed a small bug on optional belongs to with namespaced controllers.
	4	+* Allow a parameter to be given to collection_url in polymorphic cases to replace
	5	+ the parent.
	6	+* Allow InheritedResources to be called without inheritance.
	7	+* Ensure that controllers that inherit from a controller with InheritedResources
	8	+ works properly.
	9	+
	10	+# Version 0.7
	11	+
	12	+* Allow procs as default value in has scope to be able to use values from session, for example.
	13	+* Allow blocks with arity 0 or -1 to be given as the redirect url:
	14	+
	15	+ def destroy
	16	+ destroy!{ project_url(@project) }
	17	+ end
	18	+
	19	+* Allow interpolation_options to be set in the application controller.
	20	+* Added has_scope to controller (an interface for named_scopes).
	21	+* Added polymorphic_belongs_to, optional_belongs_to and singleton_belongs_to
	22	+ as quick methods.
	23	+* Only load belongs_to, singleton and polymorphic helpers if they are actually
	24	+ required. base_helpers, class_methods, dumb_responder and url_helpers are loaded
	25	+ when you inherited from base for the first time.
	26	+
	27	+# Version 0.6
	28	+
	29	+* Ensure that the default template is not rendered if the default_template_format
	30	+ is not accepted. This is somehow related with the security breach report:
	31	+
	32	+ http://www.rorsecurity.info/journal/2009/4/24/hidden-actions-render-templates.html
	33	+
	34	+ IR forbids based on mime types. For example: respond_to :html, :except => :index
	35	+ ensures that the index.html.erb view is not rendered, making your IR controllers
	36	+ safer.
	37	+
	38	+* Fixed a bug that happens only when format.xml is given to blocks and then it
	39	+ acts as default, instead of format.html.
	40	+* Fixed a strange bug where when you have create.html.erb or update.html.erb,
	41	+ it makes IE6 and IE7 return unprocessable entity (because they send Mime::ALL).
	42	+* Stop rescueing any error when constantizing the resource class and allow
	43	+ route_prefix to be nil.
	44	+* Cleaned up tests and responder structure. Whenever you pass a block to aliases
	45	+ and this block responds to the request, the other blocks are not parsed improving performance.
	46	+* [BACKWARDS INCOMPATIBLE] By default, Inherited Resources respond only :html requests.
	47	+* Added a quick way to overwrite the redirect to url in :create, :update and :destroy.
	48	+
	49	+# Version 0.5
	50	+
	51	+* Decoupled routes name from :instance_name and :collection_name. This way we
	52	+ have more flexibility. Use route_instance_name and route_collection_name to
	53	+ to change routes.
	54	+* Avoid calling human_name on nil when a resource class is not defined.
	55	+* Only call I18n if it's defined.
	56	+
	57	+# Version 0.4
	58	+
	59	+* Dealing with namespaced controllers out of the box.
	60	+* Added support to namespaced routes through :route_prefix.
	61	+* Added fix when resource_url is not defined.
	62	+* Added better handling for namespaced controllers.
	63	+* Added flash messages scoped by namespaced controllers.
	64	+* Deprecated {{resource}} in I18n, use {{resource_name}} instead.
	65	+* rspec bug fix is not automatically required anymore. User has to do it
	66	+ explicitly.
	67	+* Added a file which fix a rspec bug when render is called inside a method
	68	+ which receives a block.
	69	+* parent? does not take begin_of_association_chain into account anymore
	70	+* Added options to url helpers.
	71	+* Added :optional to belongs_to associations. It allows you to deal with
	72	+ categories/1/products/2 and /products/2 with just one controller.
	73	+* Cleaned up tests.
	74	+
	75	+# Version 0.3
	76	+
	77	+* Minor bump after three bug fixes.
	78	+* Bug fix when showing warning of constant redefinition.
	79	+* Bug fix with ApplicationController not being unloaded properly on development.
	80	+* Bug fix when having root singleton resources. Calling collection_url would
	81	+ raise "NoMethodError _url", not it will call root_url.
	82	+* More comments on UrlHelpers.
	83	+
	84	+# Version 0.2
	85	+
	86	+* Bug fix when ApplicationController is already loaded when we load respond_to.
	87	+* Added support success/failure blocks.
	88	+* Eager loading of files to work properly in multithreaded environments.
	89	+
	90	+# Version 0.1
	91	+
	92	+* Added more helper_methods.
	93	+* Added Rails 2.3.0 and changed tests to work with ActionController::TestCase.
	94	+* First release. Support to I18n, singleton controllers, polymorphic
	95	+controllers, belongs_to, nested_belongs_to and url helpers.
@@ -0,0 +1,20 @@		@@ -0,0 +1,20 @@
	1	+Copyright (c) 2009 José Valim
	2	+
	3	+Permission is hereby granted, free of charge, to any person obtaining
	4	+a copy of this software and associated documentation files (the
	5	+"Software"), to deal in the Software without restriction, including
	6	+without limitation the rights to use, copy, modify, merge, publish,
	7	+distribute, sublicense, and/or sell copies of the Software, and to
	8	+permit persons to whom the Software is furnished to do so, subject to
	9	+the following conditions:
	10	+
	11	+The above copyright notice and this permission notice shall be
	12	+included in all copies or substantial portions of the Software.
	13	+
	14	+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
	15	+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
	16	+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
	17	+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
	18	+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
	19	+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
	20	+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
@@ -0,0 +1,517 @@		@@ -0,0 +1,517 @@
	1	+Inherited Resources
	2	+License: MIT
	3	+Version: 0.8.5
	4	+
	5	+You can also read this README in pretty html at the GitHub project Wiki page:
	6	+
	7	+ http://wiki.github.com/josevalim/inherited_resources
	8	+
	9	+Description
	10	+-----------
	11	+
	12	+Inherited Resources speeds up development by making your controllers inherit
	13	+all restful actions so you just have to focus on what is important. It makes
	14	+your controllers more powerful and cleaner at the same time.
	15	+
	16	+Plus, making your controllers follow a pattern, it helps you to write better
	17	+code by following fat models and skinny controllers convention.
	18	+
	19	+Inherited Resources is tested and compatible with Rails 2.2.x and Rails 2.3.x.
	20	+
	21	+keywords: resources, controller, singleton, belongs_to, polymorphic, named_scope and I18n
	22	+
	23	+Installation
	24	+------------
	25	+
	26	+Install Inherited Resources is very easy. It is stored in GitHub, so just run
	27	+the following:
	28	+
	29	+ gem sources -a http://gems.github.com
	30	+ sudo gem install josevalim-inherited_resources
	31	+
	32	+If you want it as plugin, just do:
	33	+
	34	+ script/plugin install git://github.com/josevalim/inherited_resources.git
	35	+
	36	+rspec-rails <= 1.1.12 known bug
	37	+-------------------------------
	38	+
	39	+InheritedResources has a known bug with rspec-rails. Please upgrade your rspec
	40	+version or use the fix which ships with InheritedResources:
	41	+
	42	+ require 'inherited_resources/spec'
	43	+
	44	+Basic Usage
	45	+-----------
	46	+
	47	+To use Inherited Resources you just have to inherit (duh) it:
	48	+
	49	+ class ProjectsController < InheritedResources::Base
	50	+ end
	51	+
	52	+And all actions are defined and working, check it! Your projects collection
	53	+(in the index action) is still available in the instance variable @projects
	54	+and your project resource (all other actions) is available as @ project.
	55	+
	56	+The next step is to define which mime types this controller provides:
	57	+
	58	+ class ProjectsController < InheritedResources::Base
	59	+ respond_to :html, :xml, :json
	60	+ end
	61	+
	62	+You can also specify them based per action:
	63	+
	64	+ class ProjectsController < InheritedResources::Base
	65	+ respond_to :html, :xml, :json
	66	+ respond_to :js, :only => :create
	67	+ respond_to :iphone, :except => [ :edit, :update ]
	68	+ end
	69	+
	70	+For each request, it first checkes if the "controller/action.format" file is
	71	+available (for example "projects/create.xml") and if it's not, it checks if
	72	+the resource respond to :to_format (in this case, :to_xml). Otherwise returns 404.
	73	+
	74	+Another option is to specify which actions the controller will inherit from
	75	+the InheritedResources::Base:
	76	+
	77	+ class ProjectsController < InheritedResources::Base
	78	+ actions :index, :show, :new, :create
	79	+ end
	80	+
	81	+Or:
	82	+
	83	+ class ProjectsController < InheritedResources::Base
	84	+ actions :all, :except => [ :edit, :update, :destroy ]
	85	+ end
	86	+
	87	+In your views, you will get the following helpers:
	88	+
	89	+ resource #=> @project
	90	+ collection #=> @projects
	91	+ resource_class #=> Project
	92	+
	93	+As you might expect, collection (@projects instance variable) is only available
	94	+on index actions.
	95	+
	96	+If for some reason you cannot inherit from InheritedResources::Base, you can
	97	+call inherit_resources or resource_controller in your controller class scope:
	98	+
	99	+ class AccountsController < ApplicationController
	100	+ inherit_resources # or resource_controller
	101	+ end
	102	+
	103	+Overwriting defaults
	104	+--------------------
	105	+
	106	+Whenever you inherit from InheritedResources, several defaults are assumed.
	107	+For example you can have an AccountsController to account management while the
	108	+resource is an User:
	109	+
	110	+ class AccountsController < InheritedResources::Base
	111	+ defaults :resource_class => User, :collection_name, 'users', :instance_name => 'user'
	112	+ end
	113	+
	114	+In the case above, in your views you will have @users and @user variables, but
	115	+the routes used will still be accounts_url and account_url. If you plan also to
	116	+change the routes, you can use :route_collection_name and :route_instance_name.
	117	+
	118	+Namespaced controllers work out of the box, but if you need to specify a
	119	+different route prefix, you can do the following:
	120	+
	121	+ class Administrators::PeopleController < InheritedResources::Base
	122	+ defaults :route_prefix => 'admin'
	123	+ end
	124	+
	125	+Then your named routes will be: 'admin_people_url', 'admin_person_url' instead
	126	+of 'administrators_people_url' and 'administrators_person_url'.
	127	+
	128	+If you want to customize how resources are retrieved you can overwrite
	129	+collection and resource methods. The first is called on index action and the
	130	+second on all other actions. Let's suppose you want to add pagination to your
	131	+projects collection:
	132	+
	133	+ class ProjectsController < InheritedResources::Base
	134	+ protected
	135	+ def collection
	136	+ @projects \|\|= end_of_association_chain.paginate(params[:page]).all
	137	+ end
	138	+ end
	139	+
	140	+The end_of_association_chain returns your resource after nesting all associations
	141	+and scopes (more about this below).
	142	+
	143	+InheritedResources also introduces another method called begin_of_association_chain.
	144	+It's mostly used when you want to create resources based on the @current_user and
	145	+you have urls like "account/projects". In such cases, you have to do
	146	+@current_user.projects.find or @current_user.projects.build in your actions.
	147	+
	148	+You can deal with it just doing:
	149	+
	150	+ class ProjectsController < InheritedResources::Base
	151	+ protected
	152	+ def begin_of_association_chain
	153	+ @current_user
	154	+ end
	155	+ end
	156	+
	157	+Overwriting actions
	158	+-------------------
	159	+
	160	+Let's suppose that after destroying a project you want to redirect to your
	161	+root url instead of redirecting to projects url. You just have to do:
	162	+
	163	+ class ProjectsController < InheritedResources::Base
	164	+ def destroy
	165	+ super do \|format\|
	166	+ format.html { redirect_to root_url }
	167	+ end
	168	+ end
	169	+ end
	170	+
	171	+You are opening your action and giving the parent action a new behavior. No
	172	+tricks, no DSL, just Ruby.
	173	+
	174	+On the other hand, I have to agree that calling super is not very readable.
	175	+That's why all methods have aliases. So this is equivalent:
	176	+
	177	+ class ProjectsController < InheritedResources::Base
	178	+ def destroy
	179	+ destroy! do \|format\|
	180	+ format.html { redirect_to root_url }
	181	+ end
	182	+ end
	183	+ end
	184	+
	185	+Even more, since most of the times when you change a create, update or destroy
	186	+action is because you want to to change to where it redirects, a shortcut is
	187	+provided. So you can do:
	188	+
	189	+ class ProjectsController < InheritedResources::Base
	190	+ def destroy
	191	+ destroy!{ root_url }
	192	+ end
	193	+ end
	194	+
	195	+Now let's suppose that before create a project you have to do something special
	196	+but you don't want to create a before filter for it:
	197	+
	198	+ class ProjectsController < InheritedResources::Base
	199	+ def create
	200	+ @project = Project.new(params[:project])
	201	+ @project.something_special!
	202	+ create!
	203	+ end
	204	+ end
	205	+
	206	+Yes, that simple! The nice part is since you already set the instance variable
	207	+@project, it will not build a project again.
	208	+
	209	+Before we finish this topic, we should talk about one more thing: "success/failure
	210	+blocks". Let's suppose that when we update our project, in case of failure, we
	211	+want to redirect to the project url instead of re-rendering the edit template.
	212	+
	213	+Our first attempt to do this would be:
	214	+
	215	+ class ProjectsController < InheritedResources::Base
	216	+ def update
	217	+ update! do \|format\|
	218	+ unless @project.errors.empty? # failure
	219	+ format.html { redirect_to project_url(@project) }
	220	+ end
	221	+ end
	222	+ end
	223	+ end
	224	+
	225	+Looks to verbose, right? We can actually do:
	226	+
	227	+ class ProjectsController < InheritedResources::Base
	228	+ def update
	229	+ update! do \|success, failure\|
	230	+ failure.html { redirect_to project_url(@project) }
	231	+ end
	232	+ end
	233	+ end
	234	+
	235	+Much better! So explaining everything: when you give a block which expects one
	236	+argument it will be executed in both scenarios: success and failure. But If you
	237	+give a block that expects two arguments, the first will be executed only in
	238	+success scenarios and the second in failure scenarios. You keep everything
	239	+clean and organized inside the same action.
	240	+
	241	+Flash messages and I18n
	242	+-----------------------
	243	+
	244	+Flash messages are powered by I18n api. It checks for messages in the following
	245	+order:
	246	+
	247	+ flash.controller_name.action_name.status
	248	+ flash.actions.action_name.status
	249	+
	250	+If none is available, a default message in english set. In a create action
	251	+on projects controller, it will search for:
	252	+
	253	+ flash.projects.create.status
	254	+ flash.actions.create.status
	255	+
	256	+The status can be :notice (when the object can be created, updated
	257	+or destroyed with success) or :error (when the objecy cannot be created
	258	+or updated).
	259	+
	260	+Those messages are interpolated by using the resource class human name, which
	261	+is also localized and it means you can set:
	262	+
	263	+ flash:
	264	+ actions:
	265	+ create:
	266	+ notice: "Hooray! {{resource_name}} was successfully created!"
	267	+
	268	+It will replace {{resource_name}} by the human name of the resource class,
	269	+which is "Project" in this case.
	270	+
	271	+But sometimes, flash messages are not that simple. Sometimes you want to say
	272	+the title of the project while updating a project. Well, that's easy also:
	273	+
	274	+ flash:
	275	+ projects:
	276	+ update:
	277	+ notice: "Hooray! The project "{{project_title}}" was updated!"
	278	+
	279	+Since :project_title is not available for interpolation by default, you have
	280	+to overwrite interpolation_options.
	281	+
	282	+ def interpolation_options
	283	+ { :project_title => @project.title }
	284	+ end
	285	+
	286	+Then you will finally have:
	287	+
	288	+ "Hooray! The project "Plataforma" was updated!"
	289	+
	290	+By default, resource name is capitalized. If you want to make it lower case, you
	291	+can add to your application controller:
	292	+
	293	+ def interpolation_options
	294	+ { :resource_name => resource_class.human_name.downcase }
	295	+ end
	296	+
	297	+Finally, if your controller is namespaced, for example Admin::ProjectsController,
	298	+the messages will be checked in the following order:
	299	+
	300	+ flash.admin.projects.create.notice
	301	+ flash.admin.actions.create.notice
	302	+ flash.projects.create.notice
	303	+ flash.actions.create.notice
	304	+
	305	+Has Scope
	306	+---------
	307	+
	308	+InheritedResources tries to integrate nicely with your model. In order to do so,
	309	+it also is named_scope fluent. Let's suppose our Project model with the scopes:
	310	+
	311	+ class ProjectsController < ActiveRecord::Base
	312	+ named_scope :featured, :conditions => { :featured => true }
	313	+ named_scope :by_methodology, proc {\|methodology\| { :conditions => { :methodology => methodology } } }
	314	+ named_scope :limit, proc{\|limit\| :limit => limit.to_i }
	315	+ end
	316	+
	317	+Your controller:
	318	+
	319	+ class ProjectsController < InheritedResources::Base
	320	+ has_scope :featured, :boolean => true, :only => :index
	321	+ has_scope :by_methodology
	322	+ has_scope :limit, :default => 10
	323	+ end
	324	+
	325	+Then for each request:
	326	+
	327	+ /projects
	328	+ #=> acts like a normal request, but returning 10 projects
	329	+
	330	+ /projects?featured=true
	331	+ #=> calls the featured named scope and bring 10 featured projects
	332	+
	333	+ /projects?featured=true&by_methodology=agile&limit=20
	334	+ #=> brings 20 featured projects with methodology agile
	335	+
	336	+You can retrieve the current scopes in use with :current_scopes method.
	337	+In the last case, it would return:
	338	+
	339	+ { :featured => "true", :by_methodology => "agile", :limit => "20" }
	340	+
	341	+Finally, let's suppose you store on the session how many projects the user sees
	342	+per page. In such cases, you can give a proc as default value:
	343	+
	344	+ has_scope :limit, :default => proc{\|c\| c.session[:limit] \|\| 10 }
	345	+
	346	+Belongs to
	347	+----------
	348	+
	349	+Finally, our Projects are going to get some Tasks. Then you create a
	350	+TasksController and do:
	351	+
	352	+ class TasksController < InheritedResources::Base
	353	+ belongs_to :project
	354	+ end
	355	+
	356	+belongs_to accepts several options to be able to configure the association.
	357	+For example, if you want urls like /projects/:project_title/tasks, you can
	358	+customize how InheritedResources find your projects:
	359	+
	360	+ class TasksController < InheritedResources::Base
	361	+ belongs_to :project, :finder => :find_by_title!, :param => :project_title
	362	+ end
	363	+
	364	+It also accepts :route_name, :parent_class and :instance_name as options.
	365	+Check the lib/inherited_resources/class_methods.rb for more.
	366	+
	367	+Nested belongs to
	368	+-----------------
	369	+
	370	+Now, our Tasks get some Comments and you need to nest even deeper. Good
	371	+practices says that you should never nest more than two resources, but sometimes
	372	+you have to for security reasons. So this is an example of how you can do it:
	373	+
	374	+ class CommentsController < InheritedResources::Base
	375	+ nested_belongs_to :project, :task
	376	+ end
	377	+
	378	+If you need to configure any of these belongs to, you can nested them using blocks:
	379	+
	380	+ class CommentsController < InheritedResources::Base
	381	+ belongs_to :project, :finder => :find_by_title!, :param => :project_title do
	382	+ belongs_to :task
	383	+ end
	384	+ end
	385	+
	386	+Warning: calling several belongs_to is the same as nesting them:
	387	+
	388	+ class CommentsConroller < InheritedResources::Base
	389	+ belongs_to :project
	390	+ belongs_to :task
	391	+ end
	392	+
	393	+In other words, the code above is the same as calling nested_belongs_to.
	394	+
	395	+Polymorphic belongs to
	396	+----------------------
	397	+
	398	+We can go even further. Let's suppose our Projects can now have Files, Messages
	399	+and Tasks, and they are all commentable. In this case, the best solution is to
	400	+use polymorphism:
	401	+
	402	+ class CommentsController < InheritedResources::Base
	403	+ belongs_to :task, :file, :message, :polymorphic => true
	404	+ # polymorphic_belongs_to :task, :file, :message
	405	+ end
	406	+
	407	+You can even use it with nested resources:
	408	+
	409	+ class CommentsController < InheritedResources::Base
	410	+ belongs_to :project do
	411	+ belongs_to :task, :file, :message, :polymorphic => true
	412	+ end
	413	+ end
	414	+
	415	+The url in such cases can be:
	416	+
	417	+ /project/1/task/13/comments
	418	+ /project/1/file/11/comments
	419	+ /project/1/message/9/comments
	420	+
	421	+When using polymorphic associations, you get some free helpers:
	422	+
	423	+ parent? #=> true
	424	+ parent_type #=> :task
	425	+ parent_class #=> Task
	426	+ parent #=> @task
	427	+
	428	+Optional belongs to
	429	+-------------------
	430	+
	431	+Later you decide to create a view to show all comments, independent if they belong
	432	+to a task, file or message. You can reuse your polymorphic controller just doing:
	433	+
	434	+ class ProjectsController < InheritedResources::Base
	435	+ belongs_to :task, :file, :message, :optional => true
	436	+ # optional_belongs_to :task, :file, :message
	437	+ end
	438	+
	439	+This will handle all those urls properly:
	440	+
	441	+ /comment/1
	442	+ /tasks/2/comment/5
	443	+ /files/10/comment/3
	444	+ /messages/13/comment/11
	445	+
	446	+This is treated as a special type of polymorphic associations, thus all helpers
	447	+are available. As you expect, when no parent is found, the helpers return:
	448	+
	449	+ parent? #=> false
	450	+ parent_type #=> nil
	451	+ parent_class #=> nil
	452	+ parent #=> nil
	453	+
	454	+Singletons
	455	+----------
	456	+
	457	+Now we are going to add manager to projects. We say that Manager is a singleton
	458	+resource because a Project has just one manager. You should declare it as
	459	+has_one (or resource) in your routes.
	460	+
	461	+To declare an association as singleton, you just have to give the :singleton
	462	+option.
	463	+
	464	+ class ManagersController < InheritedResources::Base
	465	+ belongs_to :project, :singleton => true
	466	+ # singleton_belongs_to :project
	467	+ end
	468	+
	469	+It will deal with everything again and hide the action :index from you.
	470	+
	471	+URL Helpers
	472	+-----------
	473	+
	474	+When you use InheritedResources it creates some URL helpers.
	475	+And they handle everything for you. :)
	476	+
	477	+ # /posts/1/comments
	478	+ resource_url # => /posts/1/comments/#{@comment.to_param}
	479	+ resource_url(comment) # => /posts/1/comments/#{comment.to_param}
	480	+ new_resource_url # => /posts/1/comments/new
	481	+ edit_resource_url # => /posts/1/comments/#{@comment.to_param}/edit
	482	+ edit_resource_url(comment) #=> /posts/1/comments/#{comment.to_param}/edit
	483	+ collection_url # => /posts/1/comments
	484	+
	485	+ # /projects/1/tasks
	486	+ resource_url # => /projects/1/tasks/#{@task.to_param}
	487	+ resource_url(task) # => /projects/1/tasks/#{task.to_param}
	488	+ new_resource_url # => /projects/1/tasks/new
	489	+ edit_resource_url # => /projects/1/tasks/#{@task.to_param}/edit
	490	+ edit_resource_url(task) # => /projects/1/tasks/#{task.to_param}/edit
	491	+ collection_url # => /projects/1/tasks
	492	+
	493	+ # /users
	494	+ resource_url # => /users/#{@user.to_param}
	495	+ resource_url(user) # => /users/#{user.to_param}
	496	+ new_resource_url # => /users/new
	497	+ edit_resource_url # => /users/#{@user.to_param}/edit
	498	+ edit_resource_url(user) # => /users/#{user.to_param}/edit
	499	+ collection_url # => /users
	500	+
	501	+Those urls helpers also accepts a hash as options, just as in named routes.
	502	+
	503	+ # /projects/1/tasks
	504	+ collection_url(:page => 1, :limit => 10) #=> /projects/1/tasks?page=1&limit=10
	505	+
	506	+Another nice thing is that those urls are not guessed during runtime. They are
	507	+all created when your application is loaded (except for polymorphic
	508	+associations, that relies on Rails polymorphic_url).
	509	+
	510	+Bugs and Feedback
	511	+-----------------
	512	+
	513	+If you discover any bugs, please send an e-mail to jose.valim@gmail.com
	514	+If you just want to give some positive feedback or drop a line, that's fine too!
	515	+
	516	+Copyright (c) 2009 José Valim
	517	+http://josevalim.blogspot.com/
@@ -0,0 +1,35 @@		@@ -0,0 +1,35 @@
	1	+require 'rake'
	2	+require 'rake/testtask'
	3	+require 'rake/rdoctask'
	4	+
	5	+begin
	6	+ require 'jeweler'
	7	+ Jeweler::Tasks.new do \|s\|
	8	+ s.name = "inherited_resources"
	9	+ s.rubyforge_project = "inherited_resources"
	10	+ s.summary = "Inherited Resources speeds up development by making your controllers inherit all restful actions so you just have to focus on what is important."
	11	+ s.email = "jose.valim@gmail.com"
	12	+ s.homepage = "http://github.com/josevalim/inherited_resources"
	13	+ s.description = "Inherited Resources speeds up development by making your controllers inherit all restful actions so you just have to focus on what is important."
	14	+ s.authors = ['José Valim']
	15	+ s.files = FileList["[A-Z]", "{lib}//"]
	16	+ end
	17	+rescue LoadError
	18	+ puts "Jeweler, or one of its dependencies, is not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
	19	+end
	20	+
	21	+desc 'Run tests for InheritedResources.'
	22	+Rake::TestTask.new(:test) do \|t\|
	23	+ t.pattern = 'test/*/_test.rb'
	24	+ t.verbose = true
	25	+end
	26	+
	27	+desc 'Generate documentation for InheritedResources.'
	28	+Rake::RDocTask.new(:rdoc) do \|rdoc\|
	29	+ rdoc.rdoc_dir = 'rdoc'
	30	+ rdoc.title = 'InheritedResources'
	31	+ rdoc.options << '--line-numbers' << '--inline-source'
	32	+ rdoc.rdoc_files.include('README')
	33	+ rdoc.rdoc_files.include('MIT-LICENSE')
	34	+ rdoc.rdoc_files.include('lib/*/.rb')
	35	+end
@@ -0,0 +1,18 @@		@@ -0,0 +1,18 @@
	1	+# respond_to is the only file that should be loaded before hand. All others
	2	+# are loaded on demand.
	3	+#
	4	+require File.join(File.dirname(__FILE__), 'inherited_resources', 'respond_to')
	5	+
	6	+module InheritedResources; end
	7	+
	8	+class ActionController::Base
	9	+ # If you cannot inherit from InheritedResources::Base you can call
	10	+ # inherit_resource in your controller to have all the required modules and
	11	+ # funcionality included.
	12	+ #
	13	+ def self.inherit_resources
	14	+ InheritedResources::Base.inherit_resources(self)
	15	+ initialize_resources_class_accessors!
	16	+ create_resources_url_helpers!
	17	+ end
	18	+end
@@ -0,0 +1,96 @@		@@ -0,0 +1,96 @@
	1	+module InheritedResources
	2	+ RESOURCES_ACTIONS = [ :index, :show, :new, :edit, :create, :update, :destroy ] unless self.const_defined?(:RESOURCES_ACTIONS)
	3	+
	4	+ # Holds all default actions for InheritedResouces.
	5	+ module Actions
	6	+
	7	+ # GET /resources
	8	+ def index(&block)
	9	+ respond_to(:with => collection, &block)
	10	+ end
	11	+ alias :index! :index
	12	+
	13	+ # GET /resources/1
	14	+ def show(&block)
	15	+ respond_to(:with => resource, &block)
	16	+ end
	17	+ alias :show! :show
	18	+
	19	+ # GET /resources/new
	20	+ def new(&block)
	21	+ respond_to(:with => build_resource, &block)
	22	+ end
	23	+ alias :new! :new
	24	+
	25	+ # GET /resources/1/edit
	26	+ def edit(&block)
	27	+ respond_to(:with => resource, &block)
	28	+ end
	29	+ alias :edit! :edit
	30	+
	31	+ # POST /resources
	32	+ def create(&block)
	33	+ object = build_resource
	34	+ respond_block, redirect_block = select_block_by_arity(block)
	35	+
	36	+ if object.save
	37	+ set_flash_message!(:notice, '{{resource_name}} was successfully created.')
	38	+ options = { :with => object, :status => :created, :location => (resource_url rescue nil) }
	39	+
	40	+ respond_to_with_dual_blocks(true, respond_block, options) do \|format\|
	41	+ format.html { redirect_to(redirect_block ? redirect_block.call : resource_url) }
	42	+ end
	43	+ else
	44	+ set_flash_message!(:error)
	45	+ options = { :with => object.errors, :status => :unprocessable_entity }
	46	+
	47	+ respond_to_with_dual_blocks(false, respond_block, options) do \|format\|
	48	+ format.html { render :action => 'new' }
	49	+ end
	50	+ end
	51	+ end
	52	+ alias :create! :create
	53	+
	54	+ # PUT /resources/1
	55	+ def update(&block)
	56	+ object = resource
	57	+ respond_block, redirect_block = select_block_by_arity(block)
	58	+
	59	+ if object.update_attributes(params[resource_instance_name])
	60	+ set_flash_message!(:notice, '{{resource_name}} was successfully updated.')
	61	+
	62	+ respond_to_with_dual_blocks(true, block) do \|format\|
	63	+ format.html { redirect_to(redirect_block ? redirect_block.call : resource_url) }
	64	+ format.all { head :ok }
	65	+ end
	66	+ else
	67	+ set_flash_message!(:error)
	68	+
	69	+ options = { :with => object.errors, :status => :unprocessable_entity }
	70	+
	71	+ respond_to_with_dual_blocks(false, block, options) do \|format\|
	72	+ format.html { render :action => 'edit' }
	73	+ end
	74	+ end
	75	+ end
	76	+ alias :update! :update
	77	+
	78	+ # DELETE /resources/1
	79	+ def destroy(&block)
	80	+ resource.destroy
	81	+ respond_block, redirect_block = select_block_by_arity(block)
	82	+
	83	+ set_flash_message!(:notice, '{{resource_name}} was successfully destroyed.')
	84	+
	85	+ respond_to_with_dual_blocks(nil, respond_block) do \|format\|
	86	+ format.html { redirect_to(redirect_block ? redirect_block.call : collection_url) }
	87	+ format.all { head :ok }
	88	+ end
	89	+ end
	90	+ alias :destroy! :destroy
	91	+
	92	+ # Make aliases protected
	93	+ protected :index!, :show!, :new!, :create!, :edit!, :update!, :destroy!
	94	+
	95	+ end
	96	+end
@@ -0,0 +1,39 @@		@@ -0,0 +1,39 @@
	1	+module InheritedResources
	2	+ # = Base
	3	+ #
	4	+ # This is the base class that holds all actions. If you see the code for each
	5	+ # action, they are quite similar to Rails default scaffold.
	6	+ #
	7	+ # To change your base behavior, you can overwrite your actions and call super,
	8	+ # call <tt>default</tt> class method, call <<tt>actions</tt> class method
	9	+ # or overwrite some helpers in the base_helpers.rb file.
	10	+ #
	11	+ class Base < ::ApplicationController
	12	+ unloadable
	13	+
	14	+ # Overwrite inherit_resources to add specific InheritedResources behavior.
	15	+ #
	16	+ def self.inherit_resources(base)
	17	+ base.class_eval do
	18	+ include InheritedResources::Actions
	19	+ include InheritedResources::BaseHelpers
	20	+ extend InheritedResources::ClassMethods
	21	+ extend InheritedResources::UrlHelpers
	22	+
	23	+ helper_method :collection_url, :collection_path, :resource_url, :resource_path,
	24	+ :new_resource_url, :new_resource_path, :edit_resource_url, :edit_resource_path,
	25	+ :resource, :collection, :resource_class
	26	+
	27	+ base.with_options :instance_writer => false do \|c\|
	28	+ c.class_inheritable_accessor :resource_class
	29	+ c.class_inheritable_array :parents_symbols
	30	+ c.class_inheritable_hash :resources_configuration, :scopes_configuration
	31	+ end
	32	+
	33	+ protected :resource_class, :parents_symbols, :resources_configuration, :scopes_configuration
	34	+ end
	35	+ end
	36	+
	37	+ inherit_resources(self)
	38	+ end
	39	+end
@@ -0,0 +1,329 @@		@@ -0,0 +1,329 @@
	1	+# Whenever base is required load the dumb responder since it's used inside actions.
	2	+require File.dirname(__FILE__) + '/dumb_responder.rb'
	3	+
	4	+module InheritedResources
	5	+ # Base helpers for InheritedResource work. Some methods here can be overwriten
	6	+ # and you will need to do that to customize your controllers from time to time.
	7	+ #
	8	+ module BaseHelpers
	9	+
	10	+ protected
	11	+
	12	+ # This is how the collection is loaded.
	13	+ #
	14	+ # You might want to overwrite this method if you want to add pagination
	15	+ # for example. When you do that, don't forget to cache the result in an
	16	+ # instance_variable:
	17	+ #
	18	+ # def collection
	19	+ # @projects \|\|= end_of_association_chain.paginate(params[:page]).all
	20	+ # end
	21	+ #
	22	+ def collection
	23	+ get_collection_ivar \|\| set_collection_ivar(end_of_association_chain.find(:all))
	24	+ end
	25	+
	26	+ # This is how the resource is loaded.
	27	+ #
	28	+ # You might want to overwrite this method when you are using permalink.
	29	+ # When you do that, don't forget to cache the result in an
	30	+ # instance_variable:
	31	+ #
	32	+ # def resource
	33	+ # @project \|\|= end_of_association_chain.find_by_permalink!(params[:id])
	34	+ # end
	35	+ #
	36	+ # You also might want to add the exclamation mark at the end of the method
	37	+ # because it will raise a 404 if nothing can be found. Otherwise it will
	38	+ # probably render a 500 error message.
	39	+ #
	40	+ def resource
	41	+ get_resource_ivar \|\| set_resource_ivar(end_of_association_chain.find(params[:id]))
	42	+ end
	43	+
	44	+ # This method is responsable for building the object on :new and :create
	45	+ # methods. If you overwrite it, don't forget to cache the result in an
	46	+ # instance variable.
	47	+ #
	48	+ def build_resource
	49	+ get_resource_ivar \|\| set_resource_ivar(end_of_association_chain.send(method_for_build, params[resource_instance_name]))
	50	+ end
	51	+
	52	+ # This class allows you to set a instance variable to begin your
	53	+ # association chain. For example, usually your projects belongs to users
	54	+ # and that means that they belong to the current logged in user. So you
	55	+ # could do this:
	56	+ #
	57	+ # def begin_of_association_chain
	58	+ # @current_user
	59	+ # end
	60	+ #
	61	+ # So every time we instantiate a project, we will do:
	62	+ #
	63	+ # @current_user.projects.build(params[:project])
	64	+ # @current_user.projects.find(params[:id])
	65	+ #
	66	+ # The variable set in begin_of_association_chain is not sent when building
	67	+ # urls, so this is never going to happen when calling resource_url:
	68	+ #
	69	+ # project_url(@current_user, @project)
	70	+ #
	71	+ # If the user actually scopes the url, you should use belongs_to method
	72	+ # and declare that projects belong to user.
	73	+ #
	74	+ def begin_of_association_chain
	75	+ nil
	76	+ end
	77	+
	78	+ # Returns if the controller has a parent. When only base helpers are loaded,
	79	+ # it's always false and should not be overwriten.
	80	+ #
	81	+ def parent?
	82	+ false
	83	+ end
	84	+
	85	+ # Overwrite this method to provide other interpolation options when
	86	+ # the flash message is going to be set.
	87	+ #
	88	+ # def interpolation_options
	89	+ # { }
	90	+ # end
	91	+
	92	+ private
	93	+
	94	+ # Fast accessor to resource_collection_name
	95	+ #
	96	+ def resource_collection_name #:nodoc:
	97	+ self.resources_configuration[:self][:collection_name]
	98	+ end
	99	+
	100	+ # Fast accessor to resource_instance_name
	101	+ #
	102	+ def resource_instance_name #:nodoc:
	103	+ self.resources_configuration[:self][:instance_name]
	104	+ end
	105	+
	106	+ # This methods gets your begin_of_association_chain, join it with your
	107	+ # parents chain and returns the scoped association.
	108	+ #
	109	+ def end_of_association_chain #:nodoc:
	110	+ chain = symbols_for_association_chain.inject(begin_of_association_chain) do \|chain, symbol\|
	111	+ evaluate_parent(symbol, resources_configuration[symbol], chain)
	112	+ end
	113	+
	114	+ if chain
	115	+ if method_for_association_chain
	116	+ apply_scope_to(chain.send(method_for_association_chain))
	117	+ else
	118	+ # This only happens when we specify begin_of_association_chain in
	119	+ # a singletion controller without parents. In this case, the chain
	120	+ # is exactly the begin_of_association_chain which is already an
	121	+ # instance and then not scopable.
	122	+ chain
	123	+ end
	124	+ else
	125	+ apply_scope_to(resource_class)
	126	+ end
	127	+ end
	128	+
	129	+ # Returns the appropriated method to build the resource.
	130	+ #
	131	+ def method_for_build #:nodoc:
	132	+ (begin_of_association_chain \|\| parent?) ? method_for_association_build : :new
	133	+ end
	134	+
	135	+ # Returns the name of the method used for build the resource in cases
	136	+ # where we have a parent. This is overwritten in singleton scenarios.
	137	+ #
	138	+ def method_for_association_build
	139	+ :build
	140	+ end
	141	+
	142	+ # Returns the name of the method to be called, before returning the end
	143	+ # of the association chain. This is overwriten by singleton cases
	144	+ # where no method for association chain is called.
	145	+ #
	146	+ def method_for_association_chain #:nodoc:
	147	+ resource_collection_name
	148	+ end
	149	+
	150	+ # Get resource ivar based on the current resource controller.
	151	+ #
	152	+ def get_resource_ivar #:nodoc:
	153	+ instance_variable_get("@#{resource_instance_name}")
	154	+ end
	155	+
	156	+ # Set resource ivar based on the current resource controller.
	157	+ #
	158	+ def set_resource_ivar(resource) #:nodoc:
	159	+ instance_variable_set("@#{resource_instance_name}", resource)
	160	+ end
	161	+
	162	+ # Get collection ivar based on the current resource controller.
	163	+ #
	164	+ def get_collection_ivar #:nodoc:
	165	+ instance_variable_get("@#{resource_collection_name}")
	166	+ end
	167	+
	168	+ # Set collection ivar based on the current resource controller.
	169	+ #
	170	+ def set_collection_ivar(collection) #:nodoc:
	171	+ instance_variable_set("@#{resource_collection_name}", collection)
	172	+ end
	173	+
	174	+ # Helper to set flash messages. It's powered by I18n API.
	175	+ # It checks for messages in the following order:
	176	+ #
	177	+ # flash.controller_name.action_name.status
	178	+ # flash.actions.action_name.status
	179	+ #
	180	+ # If none is available, a default message is set. So, if you have
	181	+ # a CarsController, create action, it will check for:
	182	+ #
	183	+ # flash.cars.create.status
	184	+ # flash.actions.create.status
	185	+ #
	186	+ # The statuses can be :notice (when the object can be created, updated
	187	+ # or destroyed with success) or :error (when the objecy cannot be created
	188	+ # or updated).
	189	+ #
	190	+ # Those messages are interpolated by using the resource class human name.
	191	+ # This means you can set:
	192	+ #
	193	+ # flash:
	194	+ # actions:
	195	+ # create:
	196	+ # notice: "Hooray! {{resource_name}} was successfully created!"
	197	+ #
	198	+ # But sometimes, flash messages are not that simple. Going back
	199	+ # to cars example, you might want to say the brand of the car when it's
	200	+ # updated. Well, that's easy also:
	201	+ #
	202	+ # flash:
	203	+ # cars:
	204	+ # update:
	205	+ # notice: "Hooray! You just tuned your {{car_brand}}!"
	206	+ #
	207	+ # Since :car_name is not available for interpolation by default, you have
	208	+ # to overwrite interpolation_options.
	209	+ #
	210	+ # def interpolation_options
	211	+ # { :car_brand => @car.brand }
	212	+ # end
	213	+ #
	214	+ # Then you will finally have:
	215	+ #
	216	+ # 'Hooray! You just tuned your Aston Martin!'
	217	+ #
	218	+ # If your controller is namespaced, for example Admin::CarsController,
	219	+ # the messages will be checked in the following order:
	220	+ #
	221	+ # flash.admin.cars.create.status
	222	+ # flash.admin.actions.create.status
	223	+ # flash.cars.create.status
	224	+ # flash.actions.create.status
	225	+ #
	226	+ def set_flash_message!(status, default_message=nil)
	227	+ return flash[status] = default_message unless defined?(::I18n)
	228	+
	229	+ resource_name = if resource_class
	230	+ if resource_class.respond_to?(:human_name)
	231	+ resource_class.human_name
	232	+ else
	233	+ resource_class.name.humanize
	234	+ end
	235	+ else
	236	+ "Resource"
	237	+ end
	238	+
	239	+ given_options = if self.respond_to?(:interpolation_options)
	240	+ interpolation_options
	241	+ else
	242	+ {}
	243	+ end
	244	+
	245	+ options = {
	246	+ :default => default_message \|\| '',
	247	+ :resource_name => resource_name
	248	+ }.merge(given_options)
	249	+
	250	+ defaults = []
	251	+ slices = controller_path.split('/')
	252	+
	253	+ while slices.size > 0
	254	+ defaults << :"flash.#{slices.fill(controller_name, -1).join('.')}.#{action_name}.#{status}"
	255	+ defaults << :"flash.#{slices.fill(:actions, -1).join('.')}.#{action_name}.#{status}"
	256	+ slices.shift
	257	+ end
	258	+
	259	+ options[:default] = defaults.push(options[:default])
	260	+ options[:default].flatten!
	261	+
	262	+ message = ::I18n.t options[:default].shift, options
	263	+ flash[status] = message unless message.blank?
	264	+ end
	265	+
	266	+ # Used to allow to specify success and failure within just one block:
	267	+ #
	268	+ # def create
	269	+ # create! do \|success, failure\|
	270	+ # failure.html { redirect_to root_url }
	271	+ # end
	272	+ # end
	273	+ #
	274	+ def respond_to_with_dual_blocks(success, dual_block, options={}, &block) #:nodoc:
	275	+ responder = ActionController::MimeResponds::Responder.new(self)
	276	+
	277	+ if dual_block
	278	+ if dual_block.arity == 2
	279	+ dumb_responder = InheritedResources::DumbResponder.new
	280	+ if success
	281	+ dual_block.call(responder, dumb_responder)
	282	+ else
	283	+ dual_block.call(dumb_responder, responder)
	284	+ end
	285	+ else
	286	+ dual_block.call(responder)
	287	+ end
	288	+
	289	+ # Try to respond with the block given
	290	+ responder.respond_except_any
	291	+ end
	292	+
	293	+ respond_to(options.merge!(:responder => responder, :prioritize => :html), &block) unless performed?
	294	+ end
	295	+
	296	+ # Hook to apply scopes. By default returns only the target_object given.
	297	+ # It's extend by HasScopeHelpers.
	298	+ #
	299	+ def apply_scope_to(target_object) #:nodoc:
	300	+ target_object
	301	+ end
	302	+
	303	+ # Symbols chain in base helpers return nothing. This is later overwriten
	304	+ # by belongs_to and can be complex in polymorphic cases.
	305	+ #
	306	+ def symbols_for_association_chain #:nodoc:
	307	+ []
	308	+ end
	309	+
	310	+ # Holds InheritedResources block structure. It returns two blocks: the first
	311	+ # is used in respond_to blocks and the second is the redirect_to url.
	312	+ #
	313	+ def select_block_by_arity(block) #:nodoc
	314	+ if block
	315	+ case block.arity
	316	+ when 2, 1
	317	+ [block, nil]
	318	+ when 0, -1
	319	+ [nil, block]
	320	+ else
	321	+ raise ScriptError, "InheritedResources does not know how to handle blocks with arity #{block.arity}"
	322	+ end
	323	+ else
	324	+ [nil, nil]
	325	+ end
	326	+ end
	327	+
	328	+ end
	329	+end
@@ -0,0 +1,89 @@		@@ -0,0 +1,89 @@
	1	+module InheritedResources
	2	+
	3	+ # = belongs_to
	4	+ #
	5	+ # Let's suppose that we have some tasks that belongs to projects. To specify
	6	+ # this assoication in your controllers, just do:
	7	+ #
	8	+ # class TasksController < InheritedResources::Base
	9	+ # belongs_to :project
	10	+ # end
	11	+ #
	12	+ # belongs_to accepts several options to be able to configure the association.
	13	+ # For example, if you want urls like /projects/:project_title/tasks, you
	14	+ # can customize how InheritedResources find your projects:
	15	+ #
	16	+ # class TasksController < InheritedResources::Base
	17	+ # belongs_to :project, :finder => :find_by_title!, :param => :project_title
	18	+ # end
	19	+ #
	20	+ # It also accepts :route_name, :parent_class and :instance_name as options.
	21	+ # Check the lib/inherited_resources/class_methods.rb for more.
	22	+ #
	23	+ # = nested_belongs_to
	24	+ #
	25	+ # Now, our Tasks get some Comments and you need to nest even deeper. Good
	26	+ # practices says that you should never nest more than two resources, but sometimes
	27	+ # you have to for security reasons. So this is an example of how you can do it:
	28	+ #
	29	+ # class CommentsController < InheritedResources::Base
	30	+ # nested_belongs_to :project, :task
	31	+ # end
	32	+ #
	33	+ # If you need to configure any of these belongs to, you can nested them using blocks:
	34	+ #
	35	+ # class CommentsController < InheritedResources::Base
	36	+ # belongs_to :project, :finder => :find_by_title!, :param => :project_title do
	37	+ # belongs_to :task
	38	+ # end
	39	+ # end
	40	+ #
	41	+ # Warning: calling several belongs_to is the same as nesting them:
	42	+ #
	43	+ # class CommentsController < InheritedResources::Base
	44	+ # belongs_to :project
	45	+ # belongs_to :task
	46	+ # end
	47	+ #
	48	+ # In other words, the code above is the same as calling nested_belongs_to.
	49	+ #
	50	+ module BelongsToHelpers
	51	+
	52	+ protected
	53	+
	54	+ # Parent is always true when belongs_to is called.
	55	+ #
	56	+ def parent?
	57	+ true
	58	+ end
	59	+
	60	+ private
	61	+
	62	+ # Evaluate the parent given. This is used to nest parents in the
	63	+ # association chain.
	64	+ #
	65	+ def evaluate_parent(parent_symbol, parent_config, chain = nil) #:nodoc:
	66	+ instantiated_object = instance_variable_get("@#{parent_config[:instance_name]}")
	67	+ return instantiated_object if instantiated_object
	68	+
	69	+ parent = if chain
	70	+ chain.send(parent_config[:collection_name])
	71	+ else
	72	+ parent_config[:parent_class]
	73	+ end
	74	+
	75	+ parent = parent.send(parent_config[:finder], params[parent_config[:param]])
	76	+
	77	+ instance_variable_set("@#{parent_config[:instance_name]}", parent)
	78	+ end
	79	+
	80	+ # Maps parents_symbols to build association chain. In this case, it
	81	+ # simply return the parent_symbols, however on polymorphic belongs to,
	82	+ # it has some customization.
	83	+ #
	84	+ def symbols_for_association_chain #:nodoc:
	85	+ parents_symbols
	86	+ end
	87	+
	88	+ end
	89	+end