Understanding :source on a has_many_through Relationship
Published: 2021-07-30 13:27:49

As you know, associations are a crucial part of any Rails project in order to get your program to start functioning. I recently created a Ruby on Rails application called "Five Star Movies". A user can signup and review movies, as well as leave a review on other users movie reviews. While creating this application I was introduced to the concept of using ``:source`` on a ``has_many through:`` relationship. This was something I've never used before and had to familiarize myself with, so I figured I'd walk you through my thought process with me! 

###Setting Up My Associations

One of the firsts steps you should take when creating a Rails project is figuring how your models interact with one another and setting up your associations. In my application I had 4 models; user, movie, review, and genre. Each of my associations are as follows:

Movie-
```belongs_to :user
    belongs_to :genre
    has_many :reviews 
    has_many :users, through: :reviews```

Genre-

```has_many :movies 
    has_many :users, through: :movies```

Review-

```belongs_to :user
    belongs_to :movie ```

User-

```has_many :movies
    has_many :reviews 
    has_many :reviewed_movies, through: :reviews, source: :movie 
    has_many :genres, through: :movies```

If you look close enough, you'll see that one of those associations are not like the rest. As you can see, in the users model, there is an association called ``:reviewed_movies``. Again taking a closer look at it you will also see in that association is something called ``:source``. It is also important to note that the movie model is singular in source, this is the basic syntax for writing this code.

###Deciding When to Use ``has_many_through`` with ``:source``

In my Users model when setting up my associations I have a ``has_many :reviews`` and a ``has_many :reviewed_movies, through: :reviews, source: :movie``. Before deciding to use ``:source`` the second association above originally looked like; ``has_many :movies, through: :reviews``. As you can see before changing the code, the two associations for the through model are both looking to the Movie model, which can get confusing and may run you into problems. To avoid this I implemented ``:source``. Using source allows you to specifically name your associations while still being able to correctly grab the data from the proper model. 

###Importance of Implementing ``:source`` in this Application

Now that we established why the associations are set up as followed, taking a further dive into it, I wanted my users to be able to leave a review on other users movies as well as have access to all the reviews left by other users. The join table in my application is the Review model, so setting up my association like so allows the Users model to have access to the Movie model to grab all the movies with reviews left on it. This was important because it allows users to interact and see other one anothers reviews on the movies, which in turn allows for a better user experience. As you can probably see by now, using ``:source`` in my ``has_many through:`` association allowed for my application to become more dynamic and gives users access to more data. 

###Wrapping it Up!     

Using ``:source`` in your Rails application allows for the customizable naming of associations. While creating this application, researching this concept made it possible for me to be able to get my app to behave exactly how I intended for it to. This concept(a very useful one I might add!) not only improved my app, but also helped improve my skills as a developer. It is definitely something I will be using again in the future as I create more Rails applications.