Revolutionize Your App with Followship Models like Twitter and Instagram in Ruby on Rails
Tags: rails, ruby
Published: 2023-02-27 05:00:00

## Introduction

Social media platforms like Twitter and Instagram have revolutionized the way we interact with each other. One of the key features of these platforms is the ability to follow other users and see their updates on your timeline. In this blog post, we will discuss how to create followship models in Ruby on Rails, similar to those used by Twitter and Instagram.

## Creating a Followship Model

I assume we have a `User` model, which will be used for followship modeling. The first step in creating a followership model is to generate a new model in Ruby on Rails. This can be done by running the following command in the terminal:

```bash
rails generate model follow follower_id:bigint:index followed_id:bigint:index
```

This command will create a new model called 'Follow' with two attributes: `follower_id` and `followed_id.` The `follower_id` attribute represents the user following someone else, while the `followed_id` attribute represents the user being followed.

Add a unique index for the scope of `follower_id` and `followed_id` so that if a user is already following a user, then that user cannot follow that user again to keep data in the database consistent:

```ruby
class CreateFollows < ActiveRecord::Migration[7.0]
  def change
    create_table :follows do |t|
      t.bigint :follower_id
      t.bigint :followed_id

      t.timestamps
    end
    add_index :follows, :follower_id
    add_index :follows, :followed_id
    add_index :follows, [:follower_id, :followed_id], unique: true
  end
end
```

Also, update the model accordingly:

```ruby
class Follow < ApplicationRecord
  belongs_to :follower, class_name: 'User'
  belongs_to :followed, class_name: 'User'

  validates :follower_id, uniqueness: { scope: :followed_id }
  validate :follower_is_not_followed

  def follower_is_not_followed
    errors.add(:follower, 'cannot follow themselves') if follower == followed
  end
end
```

By this, we are disallowing the user to follow himself and another user he is already following.

Next, we need to set up the associations between the Follow and User models. We can do this by adding the following code to the User model:

```ruby
class User < ApplicationRecord
  has_many :active_relationships, class_name: 'Follow', foreign_key: 'follower_id', dependent: :destroy,
                                  inverse_of: :follower
  has_many :followings, through: :active_relationships, source: :followed
  has_many :passive_relationships, class_name: 'Follow', foreign_key: 'followed_id', dependent: :destroy,
                                   inverse_of: :followed
  has_many :followers, through: :passive_relationships, source: :follower
end

```

This code sets up a many-to-many relationship between the User and Follow models. It also creates two associations for each user: 'followers' and 'following.’ The 'followers' association represents the users following the current user, while the ‘following’ association represents the users the current user is following.

## Implementing Follow and Unfollow Functionality

Once the following model is set up, we can implement our application follow and unfollow functionality. In the user model, we create methods to follow and unfollow:

```ruby
class User < ApplicationRecord
  # ...
  # This method make user to follow other_user
  def follow(other_user)
    active_relationships.create(followed_id: other_user.id)
  end

  # This method make user to unfollow other_user
  def unfollow(other_user)
    active_relationships.find_by(followed_id: other_user.id)&.destroy
  end

  # This method returns true if a user is following other_user
  def following?(other_user)
    followings.include?(other_user)
  end
end
```

The 'follow' action adds the selected user to the current user's 'following' association, while the 'unfollow' action removes the selected user from the current user's 'following' association. These actions can be called from our views using links or buttons.  
  
Finally, if you want to find out the user’s followings, you can write `user.followings`; when we want to find out the user’s followers, write `user.followers`.

## Conclusion

Creating follow models in Ruby on Rails is a great way to implement social media-like functionality in your application. Following the steps outlined in this blog post, you can easily set up a many-to-many relationship between your User and Followship models and implement follow and unfollow functionality for your users. With these features, your application will be more engaging and interactive for your users.

---- 

Happy Coding!
Contact me at [sulman@hey.com](mailto:sulman@hey.com)