has_one relationship in Ruby on Rails - Mini Project: Build & Apply

Understanding has_one Relationship in Rails

📖 Scenario: You are building a simple Rails app to manage users and their profiles. Each user has exactly one profile with personal details.

🎯 Goal: Create a User model and a Profile model with a has_one relationship from User to Profile. Set up the database tables and associations correctly.

📋 What You'll Learn

Create a User model with a has_one :profile association

Create a Profile model with a belongs_to :user association

Add a foreign key user_id to the profiles table

Use Rails conventions for migrations and model files

💡 Why This Matters

🌍 Real World

Many apps have users with one profile containing personal info. This pattern keeps data organized and easy to access.

💼 Career

Understanding has_one relationships is essential for Rails developers to model real-world data correctly and build maintainable apps.

1

Create the User model

Generate a Rails model called User with a string attribute name. Write the model file app/models/user.rb with the class User inheriting from ApplicationRecord.

Ruby on Rails

# Create the User model class in app/models/user.rb
# Your code here

Hint

The User model file should define a class User that inherits from ApplicationRecord.

2

Create the Profile model with user_id foreign key

Generate a Rails model called Profile with string attributes bio and location. Add a foreign key user_id to the profiles table. Write the model file app/models/profile.rb with the class Profile inheriting from ApplicationRecord.

Ruby on Rails

class User < ApplicationRecord
end

# Create the Profile model class in app/models/profile.rb
# Your code here

Hint

The Profile model file should define a class Profile that inherits from ApplicationRecord. The migration should add user_id as a foreign key.

3

Add associations between User and Profile models

In the User model, add has_one :profile. In the Profile model, add belongs_to :user.

Ruby on Rails

class User < ApplicationRecord
  # Add has_one association here
  # Your code here
end

class Profile < ApplicationRecord
  # Add belongs_to association here
  # Your code here
end

Hint

Use has_one :profile in User and belongs_to :user in Profile.

4

Add migration to create profiles table with user_id

Write a migration to create the profiles table with string columns bio and location, and a user_id column as a foreign key referencing users. Use t.references :user, foreign_key: true in the migration.

Ruby on Rails

class User < ApplicationRecord
  has_one :profile
end

class Profile < ApplicationRecord
  belongs_to :user
end

# Write migration code here
# Your code here

Hint

Use create_table :profiles and add t.references :user, foreign_key: true to link profiles to users.

Practice

1. What does the has_one association in Rails represent?

easy

A. A many-to-many connection between two models

B. A one-to-many connection from one model to many others

C. A one-to-one connection from one model to another

D. A model inheriting from another model

Solution

1. Step 1: Understand the purpose of has_one

   The has_one association sets up a one-to-one link from one model to another, meaning each instance of the first model is connected to exactly one instance of the second model.

2. Step 2: Compare with other associations

   Unlike has_many (one-to-many) or has_and_belongs_to_many (many-to-many), has_one is strictly one-to-one.

3. Final Answer:

   A one-to-one connection from one model to another -> Option C

4. Quick Check:

   has_one = one-to-one [OK]

Hint: Remember: has_one means exactly one related record [OK]

Common Mistakes:

• Confusing has_one with has_many
• Thinking has_one creates many related records
• Mixing up has_one with belongs_to

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

easy

A. has_one = :profile

B. has_one profile

C. has_one => :profile

D. has_one :profile

Solution

1. Step 1: Recall Rails association syntax

   In Rails, associations are declared using the method name followed by a symbol representing the related model, e.g., has_one :profile.

2. Step 2: Identify correct Ruby syntax

   has_one :profile uses the correct Ruby method call with a symbol argument. Options A, B, and C are invalid Ruby syntax for this purpose.

3. Final Answer:

   has_one :profile -> Option D

4. Quick Check:

   Association syntax uses symbol with colon [OK]

Hint: Use colon before association name: has_one :name [OK]

Common Mistakes:

• Omitting the colon before the association name
• Using hash rocket syntax incorrectly
• Assigning association with equals sign

3. Given these models:

class User < ApplicationRecord
  has_one :profile
end

class Profile < ApplicationRecord
  belongs_to :user
end

What will user.profile return if the user has no profile record?

medium

A. nil

B. An error is raised

C. An empty Profile object

D. A new unsaved Profile instance

Solution

1. Step 1: Understand has_one association behavior

   If no associated record exists, calling user.profile returns nil because there is no linked profile.

2. Step 2: Confirm no automatic creation

   Rails does not create or return empty or new instances automatically for has_one associations.

3. Final Answer:

   nil -> Option A

4. Quick Check:

   No associated record means nil [OK]

Hint: No linked record? Association returns nil [OK]

Common Mistakes:

• Expecting an empty or new object instead of nil
• Assuming an error is raised when missing association
• Confusing with build_profile method

4. Identify the error in this code snippet:

class User < ApplicationRecord
  has_one :profile
end

class Profile < ApplicationRecord
  has_one :user
end

medium

A. Profile should use belongs_to :user instead of has_one

B. User should use belongs_to :profile instead of has_one

C. Both models should use has_one for the association

D. No error; the code is correct

Solution

1. Step 1: Understand correct association directions

   In a one-to-one relationship, the model holding the foreign key uses belongs_to. Here, Profile should belong to User.

2. Step 2: Identify incorrect association

   Using has_one :user in Profile is wrong because it implies Profile owns User, which is not the case.

3. Final Answer:

   Profile should use belongs_to :user instead of has_one -> Option A

4. Quick Check:

   Foreign key side uses belongs_to [OK]

Hint: belongs_to goes on model with foreign key [OK]

Common Mistakes:

• Using has_one on both sides
• Confusing which model holds foreign key
• Omitting belongs_to in related model

5. You want to ensure that when a User is deleted, their associated Profile is also deleted automatically. How do you modify the has_one association in the User model?

hard

A. has_one :profile, autosave: true

B. has_one :profile, dependent: :destroy

C. has_one :profile, validate: true

D. has_one :profile, inverse_of: :user

Solution

1. Step 1: Understand dependent option in associations

   The dependent: :destroy option tells Rails to delete the associated record when the owner is deleted.

2. Step 2: Apply to has_one association

   Adding dependent: :destroy to has_one :profile ensures the profile is removed automatically with the user.

3. Final Answer:

   has_one :profile, dependent: :destroy -> Option B

4. Quick Check:

   dependent: :destroy deletes associated record [OK]

Hint: Use dependent: :destroy to auto-delete associated record [OK]

Common Mistakes:

• Using autosave or validate instead of dependent
• Forgetting to add dependent option
• Confusing inverse_of with dependent