Polymorphic associations in Ruby on Rails - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

How does polymorphic association behave in Rails?

Given a polymorphic association where Comment belongs to commentable which can be either Post or Image, what will comment.commentable return if the comment belongs to a post?

Ruby on Rails

class Comment < ApplicationRecord
  belongs_to :commentable, polymorphic: true
end

class Post < ApplicationRecord
  has_many :comments, as: :commentable
end

post = Post.create(title: "Hello")
comment = Comment.create(body: "Nice post!", commentable: post)

result = comment.commentable

A The Post object associated with the comment

B The Comment object itself

C An array of all comments for the post

D A string with the post's title

💡 Hint

Think about what belongs_to :commentable means in Rails.

The commentable method returns the actual object the comment belongs to, which is the Post instance in this case.

📝 Syntax

intermediate

Identify the correct polymorphic association syntax

Which option correctly defines a polymorphic association in Rails?

A

class Picture < ApplicationRecord
  belongs_to :imageable
end

B

class Picture < ApplicationRecord
  has_many :imageable, polymorphic: true
end

C

class Picture < ApplicationRecord
  belongs_to :imageable, polymorphic: true
end

D

class Picture < ApplicationRecord
  has_one :imageable, polymorphic: true
end

💡 Hint

Remember that the model holding the foreign key uses belongs_to with polymorphic: true.

The model that stores the polymorphic foreign keys uses belongs_to :association_name, polymorphic: true. Other models use has_many or has_one without polymorphic.

🔧 Debug

advanced

Why does this polymorphic association raise an error?

Given the following code, why does comment.commentable raise ActiveRecord::RecordNotFound?

Ruby on Rails

class Comment < ApplicationRecord
  belongs_to :commentable, polymorphic: true
end

comment = Comment.create(body: "Test", commentable_type: "Post", commentable_id: 9999)
comment.commentable

A Because belongs_to requires inverse_of option for polymorphic

B Because there is no Post record with id 9999 in the database

C Because commentable_type should be lowercase 'post'

D Because the polymorphic association is missing the :dependent option

💡 Hint

Check if the associated record exists in the database.

The error occurs because Rails tries to find a Post with id 9999, which does not exist, causing ActiveRecord::RecordNotFound.

❓ state_output

advanced

What is the count of comments for a polymorphic association?

Given a Post with 3 comments and an Image with 2 comments, what is the output of Comment.where(commentable_type: 'Post').count?

Ruby on Rails

post = Post.create(title: "Post")
image = Image.create(name: "Image")
3.times { Comment.create(body: "Post comment", commentable: post) }
2.times { Comment.create(body: "Image comment", commentable: image) }

result = Comment.where(commentable_type: 'Post').count

A 3

B 5

C 2

D 0

💡 Hint

Filter comments by the commentable_type column.

The query counts only comments where commentable_type is 'Post', which are 3.

🧠 Conceptual

expert

Why use polymorphic associations in Rails?

Which is the best explanation for why polymorphic associations are useful in Rails?

A They replace the need for join tables in many-to-many relationships

B They enforce strict foreign key constraints between models

C They automatically generate database indexes for faster queries

D They allow a model to belong to more than one other model on a single association

💡 Hint

Think about how one model can be linked to different models using the same association.

Polymorphic associations let a model belong to multiple other models through one association, making code simpler and more flexible.

Practice

1. What is the main purpose of polymorphic associations in Rails?

easy

A. To allow a model to belong to more than one other model using a single association

B. To create a one-to-one relationship between two models

C. To enforce database constraints on foreign keys

D. To automatically generate views for multiple models

Solution

1. Step 1: Understand polymorphic association concept

   Polymorphic associations let one model belong to multiple other models through a single interface.

2. Step 2: Compare options with concept

   To allow a model to belong to more than one other model using a single association correctly describes this flexibility. Other options describe unrelated features.

3. Final Answer:

   To allow a model to belong to more than one other model using a single association -> Option A

4. Quick Check:

   Polymorphic association = flexible belongs_to [OK]

Hint: Polymorphic means one interface for many models [OK]

Common Mistakes:

• Thinking it creates one-to-one relationships
• Confusing with database foreign key constraints
• Assuming it auto-generates views

2. Which of the following is the correct syntax to declare a polymorphic belongs_to association in a Rails model?

easy

A. has_many :commentable, polymorphic: true

B. has_one :commentable, polymorphic: true

C. belongs_to :commentable, as: :polymorphic

D. belongs_to :commentable, polymorphic: true

Solution

1. Step 1: Recall belongs_to polymorphic syntax

   The correct syntax uses belongs_to :name, polymorphic: true in the model that belongs to multiple types.

2. Step 2: Match options with syntax

   belongs_to :commentable, polymorphic: true matches this exactly. Options A and D use wrong association types, and C uses incorrect keyword.

3. Final Answer:

   belongs_to :commentable, polymorphic: true -> Option D

4. Quick Check:

   belongs_to with polymorphic: true = belongs_to :commentable, polymorphic: true [OK]

Hint: belongs_to uses polymorphic: true, has_many uses as: :name [OK]

Common Mistakes:

• Using has_many instead of belongs_to for polymorphic
• Using 'as: :polymorphic' instead of 'polymorphic: true'
• Confusing has_one with belongs_to

3. Given these models:

class Comment < ApplicationRecord
  belongs_to :commentable, polymorphic: true
end

class Post < ApplicationRecord
  has_many :comments, as: :commentable
end

class Photo < ApplicationRecord
  has_many :comments, as: :commentable
end

What will post.comments.first.commentable_type return if the first comment belongs to a Post?

medium

A. "Photo"

B. "Comment"

C. "Post"

D. nil

Solution

1. Step 1: Understand polymorphic type storage

   The polymorphic association stores the class name of the associated object in commentable_type.

2. Step 2: Identify the associated model

   The comment belongs to a Post, so commentable_type will be "Post".

3. Final Answer:

   "Post" -> Option C

4. Quick Check:

   commentable_type stores class name = "Post" [OK]

Hint: commentable_type holds the class name of associated model [OK]

Common Mistakes:

• Confusing commentable_type with comment class
• Expecting the associated object instead of its type string
• Assuming nil if association exists

4. You have this model:

class Picture < ApplicationRecord
  belongs_to :imageable, polymorphic: true
end

Which of these will cause an error when creating a Picture?

medium

A. Picture.create(imageable_type: nil, imageable_id: 2)

B. Picture.create(imageable_type: "Product", imageable_id: 2)

C. Picture.create(imageable_type: "User", imageable_id: 1)

D. Picture.create(imageable_type: "User", imageable_id: 3)

Solution

1. Step 1: Check required polymorphic keys

   Polymorphic belongs_to requires both imageable_type and imageable_id to be present for a valid association.

2. Step 2: Identify missing or nil values

   Picture.create(imageable_type: nil, imageable_id: 2) has imageable_type: nil, which breaks the association and causes an error.

3. Final Answer:

   Picture.create(imageable_type: nil, imageable_id: 2) -> Option A

4. Quick Check:

   Missing polymorphic type causes error [OK]

Hint: Both type and id must be present for polymorphic belongs_to [OK]

Common Mistakes:

• Assuming nil imageable_type is acceptable
• Ignoring missing type causes runtime error
• Confusing polymorphic keys with normal foreign keys

5. You want to add comments to both Articles and Events using polymorphic associations. Which setup correctly models this?

hard

A. class Comment < ApplicationRecord
belongs_to :article
belongs_to :event
end

B. class Comment < ApplicationRecord
belongs_to :commentable, polymorphic: true
end

class Article < ApplicationRecord
has_many :comments, as: :commentable
end

class Event < ApplicationRecord
has_many :comments, as: :commentable
end

C. class Comment < ApplicationRecord
has_many :articles
has_many :events
end

D. class Article < ApplicationRecord
belongs_to :comment
end

class Event < ApplicationRecord
belongs_to :comment
end

Solution

1. Step 1: Identify polymorphic association pattern

   Comments belong to a polymorphic commentable interface, allowing multiple models to share comments.

2. Step 2: Match correct model declarations

   class Comment < ApplicationRecord belongs_to :commentable, polymorphic: true end class Article < ApplicationRecord has_many :comments, as: :commentable end class Event < ApplicationRecord has_many :comments, as: :commentable end correctly uses belongs_to :commentable, polymorphic: true in Comment and has_many :comments, as: :commentable in Article and Event.

3. Final Answer:

   polymorphic belongs_to and has_many as: :commentable -> Option B

4. Quick Check:

   Polymorphic belongs_to + has_many as: = class Comment < ApplicationRecord belongs_to :commentable, polymorphic: true end class Article < ApplicationRecord has_many :comments, as: :commentable end class Event < ApplicationRecord has_many :comments, as: :commentable end [OK]

Hint: Use belongs_to polymorphic in child, has_many as: in parents [OK]

Common Mistakes:

• Trying to belongs_to both models separately
• Using has_many in Comment instead of belongs_to
• Assigning belongs_to comment in parent models