Rails 3, has_many :through and :polymorphic - Should I need to do this?

Ok so here goes. I don't know if I'm over complicating things or if I'm just still so new to Rails that I don't understand the basics. What I want in sudo code is this:

User
has_many projects as owner through relationship
has_many projects as contributor through relationship
has_many projects as follower through relationship

Project
has_one user as owner through relationship
has_many users as followers through relationship
has_many users as contributors through relationship

Relationship
belongs_to user
belongs_to project

Then I'm wanting to have the following magical things:

owner = Project.owner
followers = Project.followers
contributors = Project.contributors

projects = User.projects
myprojects = User.projects... (now I'm really not sure)
followedProjects = ...
con开发者_高级运维tributingProjects = ...

So in writing that down I can see that there is another gap in my understanding of this model. The users can have the role of owner, follower or contributor or any combination of all three.

In terms of real code I have added here what I think is the relevant parts:

class User < ActiveRecord::Base
  has_many :user_project_relationships, :as => :relateable, :class_name => "UserProjectRelationship"
  has_many :projects, :as => :owner, :through => :relateable, :class_name => "Project", :source_type => :owner
  has_many :projects, :as => :follower, :through => :relateable, :class_name => "Project", :source_type => :follower
  has_many :projects, :as => :contributor, :through => :relateable, :class_name => "Project", :source_type => :contributor
end

class Project < ActiveRecord::Base
  has_many :user_project_relationships, :as => :relateable, :class_name => "UserProjectRelationship"
  has_one :user, :as => :owner, :through => :relateable, :class_name => "User"
  has_many :users, :as => :followers, :through => :relateable, :source_type => :follower, :class_name => "User"
  has_many :users, :as => :contributors, :through => :relateable, :source_type => :contributor, :class_name => "User"
end

class UserProjectRelationship < ActiveRecord::Base
  belongs_to :user
  belongs_to :project, :polymorphic => true
end

The migration for the relationships model is:

class CreateUserProjectRelationships < ActiveRecord::Migration
  def self.up
    create_table :user_project_relationships do |t|
      t.integer :relateable_id
      t.string :relateable_type
      t.integer :project_id
      t.timestamps
    end
    add_index :user_project_relationships, [:relateable_id, :relateable_type], :name => :relateable
    add_index :user_project_relationships, :project_id
  end

  def self.down
    drop_table :user_project_relationships
  end
end

Currently I get errors for things like project.users ActiveRecord::HasManyThroughAssociationNotFoundError: Could not find the association :relateable in model Project

I feel like I'm too in the wilderness here to really get what I want, and maybe relying on magical rails to do more than it does. Any guidance on the best path would be greatly appreciated.

Thanks in advance

Steve

Rails can do alot, but I think instead you're trying to make the Relationship model do too much. Each of those are a different kind of relationship, so I think try to keep them so.

Split that up into separate join models:

class User < ActiveRecord::Base

  has_many :owned_projects, :class_name => "Project", :foreign_key => :owner_id

  has_many :projects_followers
  has_many :followed_projects, :class_name => "Project", :through => :projects_followers

  has_many :projects_contributors
  has_many :contributed_projects, :class_name => "Project", :through => :projects_contributors

end

class Project < ActiveRecord::Base
  belongs_to :owner

  has_many :projects_followers
  has_many :followers, :class_name => "User", :through => :projects_followers


  has_many :projects_contributors, :foreign_key => :contributor_id
  has_many :contributors, :class_name => "User", :through => :projects_contributors

end

class ProjectsFollowers < ActiveRecord::Base
  belongs_to :user
  belongs_to :project
end

class ProjectsContributors < ActiveRecord::Base
  belongs_to :user
  belongs_to :project
end

Should be a lot closer to what you want. You can then indeed do

project.owner
project.followers
project.contributors

and

user.owned_projects
user.followed_projects
user.contributed_projects

That should either work, or get you pretty close.

I think your mixup came from trying to make a polymorphic relationship, which I don't think is desireable here. AFAI grok, the use case for polymorphic relationships is when you want 1 Model to be related to Any number of other models in the same way. That's not the case here, as you have 2 models with 3 different types of relationships between them.