how to ignore :type in some cases? (when I don't want STI)

Hi,

I have a model Member containing details such as name, address, phone, etc.
There are various approval stages for new and changed members so I need a few extra models based on member, some can use STI, some I'd prefer not to use STI.

MemberMod which stores a modified member in the members table using STI. This is necessary because there are approval stages to a modification. This is working fine and the simplified model looks like this:

  class MemberMod < Member     belongs_to :original_member, :class_name => 'Member',       :foreign_key => :original_member_id   end

I have a few other models that are very similar to MemberMod (such as MemberTransfer) which should have no problem using the STI method, however ...

I'm now creating a MemberProposal model which needs all the fields of a Member and a bunch more. I was planning to use a member_proposals table for the extra details but to store the routine member details in the members table (to avoid duplicating it all) - however I need the record in members table to be easily recognizable as a "proposed member" not a "member" - I have issues, here's the simplified model:

  class MemberProposal < ActiveRecord::Base     # most details we store in a member record with type set to MemberProposal     belongs_to :member   end

The issue is that when I try to access models that belong_to member it fails, things like:

  member_proposal.member.club   member_proposal.member.state   member_proposal.member.country

It fails because it thinks Member is a MemberProposal and not a Member (technically I suppose it's correct). Is there any way to turn off the magic interpretation of member[:type] for this use case or do I need to change my scheme entirely?

Thanks

I have a model Member containing details such as name, address, phone, etc.
There are various approval stages for new and changed members so I need a few extra models based on member, some can use STI, some I'd prefer not to use STI.

It fails because it thinks Member is a MemberProposal and not a Member (technically I suppose it's correct). Is there any way to turn off the magic interpretation of member[:type] for this use case or do I need to change my scheme entirely?

I'd consider re-architecting your design. Creating new member-like models for members with different approval stages seems clunky to me. How about simply having Member and ApprovalStage models, so that you can find members by approval stage?

First thanks for reply. Yes, I realized I was going down a very dark road the more I thought about this. STI provides just a little too much magic (I had already hacked around it for a few cases). I think abstract classes are the way to go:

* MemberDetails = abstract class (no table) base for all other types of member * Member = regular member * MemberProposal = mostly like a member but with some extra detail * MemberMod = all fields of a member plus pointer to the original member * MemberTransfer = similar to MemberMod

By using an abstract base class all my validations can be in the single model and I can continue to use all of the code I've developed without change (a nice bonus).

I had wanted to avoid having multiple very similar tables but the more I think about it I don't see a problem with it.