My Rails views and controllers are littered with `redirect_to`, `link_to`, and `form_for` method calls. Sometimes `link_to` and `redirect_to` are explicit in the paths they're linking (e.g. `link_to 'New Person', new_person_path`), but many times the paths are implicit (e.g. `link_to 'Show', person`). 

I add some single table inheritance (STI) to my model (say `Employee < Person`), and all of these methods break for an instance of the subclass (say `Employee`); when rails executes `link_to @person`, it errors with `undefined method employee_path' for #<#<Class:0x000001022bcd40>:0x0000010226d038>`. Rails is looking for a route defined by the class name of the object, which is employee. These employee routes are not defined, and there is no employee controller so the actions aren't defined either.

This question has been asked before:

1. At [StackOverflow](https://stackoverflow.com/questions/1773367/link-to-issue-with-inherited-active-record-class), the answer is to edit every instance of link\_to etc in your entire codebase, and state the path explicitly
2. On [StackOverflow](https://stackoverflow.com/questions/702728/get-route-for-base-class-of-sti-class-in-rails) again, two people suggest using `routes.rb` to map the subclass resources to the parent class (`map.resources :employees, :controller => 'people'`). The top answer in that same SO question suggests type-casting every instance object in the codebase using `.becomes`
3. Yet another one at [StackOverflow](https://stackoverflow.com/questions/4432858/broken-rails-routes-after-implementing-single-table-inheritance), the top answer is way in the Do Repeat Yourself camp, and suggests creating duplicate scaffolding for every subclass.
4. [Here's](https://stackoverflow.com/questions/943300/single-table-inheritance-routing) the same question again at SO, where the top answer seems to just be wrong (Rails magic Just Works!)
5. Elsewhere on the web, I found [this blog post](http://strugglingwithruby.blogspot.com/2008/10/single-table-inheritance.html) where F2Andy recommends editing in the path everywhere in the code.
6. On the blog post [Single Table Inheritance and RESTful Routes](http://blog.lrdesign.com/2009/03/single-table-inheritance-and-restful-routes/) at Logical Reality Design, it is recommended to map the resources for the subclass to the superclass controller, as in SO answer number 2 above.
7. Alex Reisner has a post [Single Table Inheritance in Rails](http://www.alexreisner.com/code/single-table-inheritance-in-rails), in which he advocates against mapping the resources of the child classes to the parent class in `routes.rb`, since that only catches routing breakages from `link_to` and `redirect_to`, but not from `form_for`. So he recommends instead adding a method to the parent class to get the subclasses to lie about their class. Sounds good, but his method gave me the error `undefined local variable or method `child' for #`.

So the answer that seems most elegant and has the most consensus (but it's not all *that* elegant, nor *that* much consensus), is the add the resources to your `routes.rb`. Except this doesn't work for `form_for`. I need some clarity! To distill the choices above, my options are

1. map the resources of the subclass to the controller of the superclass in `routes.rb` (and hope I don't need to call form\_for on any subclasses)
2. Override rails internal methods to make the classes lie to each other
3. Edit every instance in the code where the path to an object's action is invoked implicitly or explicitly, either changing the path or type-casting the object.

With all these conflicting answers, I need a ruling. It seems to me like there is no good answer. Is this a failing in rails' design? If so, is it a bug that may get fixed? Or if not, then I'm hoping someone can set me straight on this, walk me through the pros and cons of each option (or explain why that's not an option), and which one is the right answer, and why. Or is there a right answer that I'm not finding on the web?