Ruby on Rails Associations — belongs_to has_many has_one and has_many_through Explained

# app/models/comment.rb
class Comment < ApplicationRecord
  belongs_to :article
  belongs_to :user
end

# app/models/article.rb
class Article < ApplicationRecord
  belongs_to :author, class_name: "User"
end

class Comment < ApplicationRecord
  # Standard
  belongs_to :article

  # Optional — allows nil foreign key
  belongs_to :reviewer, class_name: "User", optional: true

  # Counter cache — stores comments_count on article
  belongs_to :article, counter_cache: true

  # Touch — updates article's updated_at
  belongs_to :article, touch: true

  # With foreign key specified
  belongs_to :author, class_name: "User", foreign_key: :author_id

  # Default scope on association
  belongs_to :article, -> { where(published: true) }

  # Polymorphic
  belongs_to :commentable, polymorphic: true
end

# app/models/user.rb
class User < ApplicationRecord
  has_many :articles
  has_many :comments
  has_many :bookmarks
end

# app/models/article.rb
class Article < ApplicationRecord
  has_many :comments, dependent: :destroy
end

class User < ApplicationRecord
  # Standard
  has_many :articles

  # Dependent behavior
  has_many :comments, dependent: :destroy        # Delete comments
  has_many :sessions, dependent: :delete_all      # Fast delete (no callbacks)
  has_many :logs, dependent: :nullify             # Set user_id to nil

  # Custom scope
  has_many :published_articles, -> { where(published: true) },
           class_name: "Article"

  # Through association
  has_many :categories, through: :articles

  # Source (for through with different name)
  has_many :favorited_articles, through: :favorites, source: :article

  # With foreign key
  has_many :owned_articles, class_name: "Article", foreign_key: :owner_id

  # Inverse
  has_many :articles, inverse_of: :author
end

# app/models/user.rb
class User < ApplicationRecord
  has_one :profile
  has_one :account_settings

  # Through another association
  has_one :avatar, through: :profile

  # Dependent
  has_one :preferences, dependent: :destroy
end

# app/models/profile.rb
class Profile < ApplicationRecord
  belongs_to :user
  has_one :avatar, dependent: :destroy
end

class User < ApplicationRecord
  has_one :profile, dependent: :destroy

  # With custom class
  has_one :settings, class_name: "AccountSetting"

  # Through
  has_one :avatar, through: :profile

  # Required (Rails 7+)
  has_one :profile, required: true
end

# app/models/user.rb
class User < ApplicationRecord
  has_many :articles
  has_many :comments
  has_many :categories, through: :articles

  # For many-to-many with additional data
  has_many :memberships
  has_many :groups, through: :memberships
end

# app/models/membership.rb
class Membership < ApplicationRecord
  belongs_to :user
  belongs_to :group

  # Join model can have extra attributes
  validates :role, inclusion: { in: %w[member admin owner] }
end

# app/models/group.rb
class Group < ApplicationRecord
  has_many :memberships, dependent: :destroy
  has_many :users, through: :memberships
end

class Article < ApplicationRecord
  has_and_belongs_to_many :tags
end

class Tag < ApplicationRecord
  has_and_belongs_to_many :articles
end

# Find articles by user
user = User.find(1)
drafts = user.articles.where(published: false)

# Chain through multiple associations
user.categories.where(name: "Ruby")

# Eager load to avoid N+1
users = User.includes(articles: [:comments, :tags])
users.each do |u|
  u.articles.each { |a| a.comments.each { |c| puts c.body } }
end

# Join
User.joins(:articles).where(articles: { published: true }).distinct

# Association count
user.articles.size       # Uses counter_cache if available
user.articles.count      # Always COUNT query
user.articles.length     # Loads and counts in memory

# app/models/comment.rb
class Comment < ApplicationRecord
  belongs_to :commentable, polymorphic: true
end

# app/models/article.rb
class Article < ApplicationRecord
  has_many :comments, as: :commentable
end

# app/models/photo.rb
class Photo < ApplicationRecord
  has_many :comments, as: :commentable
end

class User < ApplicationRecord
  has_many :articles, after_add: :notify_new_article,
                      after_remove: :cleanup_article

  private

  def notify_new_article(article)
    NotificationService.new_article(article)
  end

  def cleanup_article(article)
    # Cleanup when article is removed
  end
end

# Bad — no index on foreign key
add_reference :comments, :article

# Good — indexed
add_reference :comments, :article, foreign_key: true, index: true

# Bad — queries database for every article's comments
@articles.each { |a| a.comments.each { |c| puts c.body } }

# Good — eager loads in 2 queries
@articles = Article.includes(:comments)

# Bad — orphaned comments when article is deleted
has_many :comments

# Good — cascade delete
has_many :comments, dependent: :destroy

# Bad — can't add attributes to the join
has_and_belongs_to_many :tags

# Good — when join needs extra data
has_many :taggings, dependent: :destroy
has_many :tags, through: :taggings

# Bad — circular dependency on destroy
class User < ApplicationRecord
  has_many :articles, dependent: :destroy
end

class Article < ApplicationRecord
  belongs_to :user, touch: true
  after_destroy :notify_user
end

rails new blog_associations
cd blog_associations

# Generate models
bin/rails generate model User name:string email:string
bin/rails generate model Article title:string body:text user:references
bin/rails generate model Comment body:text user:references article:references
bin/rails db:migrate

# In console
user = User.create!(name: "Alice", email: "alice@test.com")
article = user.articles.create!(title: "My Post", body: "Hello!")
comment = article.comments.create!(user: user, body: "Great post!")

puts user.articles.count          # 1
puts article.comments.count       # 1
puts comment.user.name            # Alice
puts User.joins(:articles).distinct.count  # 1