In building my first Ruby on Rails app, I needed to create a facebook / social-networking style friend relationship between users. The simple requirements were that it the friendship should require approval (e.g. a friend request followed by an accept or ignore) and it should be lightweight (not using two records for a single relationship).

This method and code is inspired by two blog posts, which got me started but neither of which really fulfilled my complete requirement. The first used two records per friendship and the second was a twitter-style friend/follower without the approval process.

So, here I break down my Friendship model which hopefully you will find useful and/or insightful as a complete solution or a starting point for your own implementation.

First step is to generate a new model that we’ll call Friendship.  A Friendship will connect two users, tracking who made the request, who the friend is, and whether the request has been approved. So we generate it like so:

$ script/generate model Friendship user_id:integer friend_id:integer approved:boolean

This will create the db migration script and the app/models/friendship.rb file which we’re going to edit to include relationships to the User model. When first created, the Friendship model will be mostly empty so we need to add two lines.

class Friendship < ActiveRecord::Base
  belongs_to :user
  belongs_to :friend, :class_name => "User", :foreign_key => "friend_id"
end

The first line is obviously creating a relationship to the User model, but the second line is a little more complex. It also needs to create a relationship to the User model (there isn’t a Friend model) but we want to refer to this as the friend. So we have to specify both the :class_name and the :foreign_key so that Rails knows how to hook up this :friend field to actual models.

Now that we have a Friendship, we need to configure the User model to allow for these self-referential relationship through the Friendship model. Before we hit the code, let’s walk through the concepts here that define the state of friendships and friends.

A friendship is a two-way relationship which is initiated by one user and approved by the other user. So, we have two states of a friendship (not-approved-yet or approved) and we have two directions of friendship relative to the current user: friendships requested by the current user (we’ll call these “direct” friendships), and friendships requested to the current user (we’ll call these “inverse” friendships).

So using this terminology, we have 4 possible states of Friendship:
1) direct approved
2) indirect approved
3) direct not-approved
4) indirect not-approved

States #1 and #2 are simply what we will be calling “friends” – they are approved relationships, no matter the direction. Because we don’t care who requested the friendship once it’s approved, we will group these together.

State #3 is what we call “pending friends” – other users whom the current user has requested to be friends with and which are awaiting the other user’s approval. These are out of the control of the current user, and just waiting to be approved or rejected.

State #4 is what we’ll call “requested friends” – other users who have requested that the current user be their friend, and are awaiting the current user’s approval. These are the actionable items for the current user to approve. Ignoring a friend request simply deletes the non-approved Friendship, which is the Facebook method (doesn’t tell the other person they were rejected, but allows them to send another request if they want.)

Now that we have that groundwork, here is the User model:

class User < ActiveRecord::Base
  [...]
  has_many :friendships
  has_many :inverse_friendships, :class_name => "Friendship", :foreign_key => "friend_id"
  has_many :direct_friends, :through => :friendships, :conditions => "approved = true", :source => :friend
  has_many :inverse_friends, :through => :inverse_friendships, :conditions => "approved = true", :source => :user

  has_many :pending_friends, :through => :friendships, :conditions => "approved = false", :foreign_key => "user_id", :source => :user
  has_many :requested_friendships, :class_name => "Friendship", :foreign_key => "friend_id", :conditions => "approved = false"

  def friends
    direct_friends | inverse_friends
  end
  [...]
end

The first two lines are pretty self-explanatory as the first references our “direct” Friendships and the second our “inverse” Friendships which we’ll be using as the basis of all of our friend lists. Lines 5 and 6 simply create our direct and inverse friend lists, only looking at friendships which have been approved. These are states #1 and #2 from our discussion above and are complete, approved bi-directional friends lists.

Line 8 here creates the list of pending friends (state #3 above) by looking for direct friendships which have not been approved. Then finally in line 9 we handle state #4 which are the “requested friendship” waiting for us to approve them, by taking all the non-approved Friendships where the current user is the target of the request (which is why we specify the foreign_key of “friend_id”).

And finally, because it would be a hassle to deal with two lists of approved friends, we create a method to simply combine them under the name of “friends”, in lines 11-13.

That’s it! You should be able to create and manage facebook-style friend requests now.

I’m not going to cover creation of the Friendship controller here in this post, but I may in the future if people would find it helpful. In short, the controller needs to handle just five actions: index, create, approve, ignore, delete. In my implementation, all actions except for index are used only for ajax calls through link_to_remote, so they’re pretty lightweight.

Updated: the direct_friends line in the User model above was incorrectly using “:source => :user” when it should be “:source => :friend” so that the returned models are the Friends you requested, not yourself the requestor.

• BROWSE / IN TIMELINE
• « Rails Deployment: Engine Yard or Heroku?
• » Running Rails 3 using RVM

• BROWSE / IN ruby on rails
• « Rails Deployment: Engine Yard or Heroku?
• » Running Rails 3 using RVM