Ruby OOP Patterns

Complete guide to Object-Oriented Programming in Ruby and Ruby on Rails, from fundamentals to advanced patterns.

Ruby OOP Fundamentals

Classes and Objects

Basic class definition

class User

Class variables (shared across all instances)

@@user_count = 0

Constants

DEFAULT_ROLE = 'member'

Constructor

def initialize(name, email) @name = name # Instance variable @email = email @role = DEFAULT_ROLE @@user_count += 1 end

Instance method

def greet "Hello, I'm #{@name}" end

Class method (alternative syntax)

def self.count @@user_count end

Class method (using class << self)

class << self def reset_count @@user_count = 0 end end end

user = User.new('Alice', 'alice@example.com') user.greet # => "Hello, I'm Alice" User.count # => 1

Attribute Accessors

class Product

Read and write

attr_accessor :name, :price

Read only

attr_reader :created_at

Write only

attr_writer :internal_code

def initialize(name, price) @name = name @price = price @created_at = Time.current end end

Equivalent to:

class Product def name @name end

def name=(value) @name = value end

def created_at @created_at end

def internal_code=(value) @internal_code = value end end

Method Visibility

class BankAccount def initialize(balance) @balance = balance end

Public methods (default visibility)

def deposit(amount) validate_amount(amount) @balance += amount end

Protected methods (callable by instances of same class or subclasses)

protected

def compare_balance(other_account) @balance <=> other_account.balance end

def balance @balance end

Private methods (only callable within instance)

private

def validate_amount(amount) raise ArgumentError, "Amount must be positive" unless amount > 0 end end

Modern Ruby 3.x private syntax

class BankAccount def deposit(amount) validate_amount(amount) # OK - called on self @balance += amount end

private

Can also use inline private

private def validate_amount(amount) raise ArgumentError, "Amount must be positive" unless amount > 0 end end

Self Keyword

class Document attr_accessor :title

def initialize(title) @title = title end

Instance method - self refers to instance

def display_title self.title # same as @title end

Class method - self refers to class

def self.create_default new("Untitled") # same as self.new("Untitled") end

Comparing self

def same_as?(other) self == other end

Returning self for method chaining

def set_title(title) @title = title self # Return self for chaining end end

doc = Document.new("Report") doc.set_title("Annual Report").display_title

Singleton Methods

Define method on specific object instance

user = User.new("Alice", "alice@example.com")

def user.special_greeting "Special greeting for #{@name}" end

user.special_greeting # Works other_user = User.new("Bob", "bob@example.com") other_user.special_greeting # NoMethodError

Modules

Modules as Mixins

Shared behavior across classes

module Timestampable def mark_created @created_at = Time.current end

def mark_updated @updated_at = Time.current end

def timestamps { created_at: @created_at, updated_at: @updated_at } end end

class Article include Timestampable

def initialize(title) @title = title mark_created end end

class Comment include Timestampable

def initialize(body) @body = body mark_created end end

article = Article.new("Title") article.timestamps

Modules as Namespaces

module Analytics class Report def generate "Analytics Report" end end

class Dashboard def display "Analytics Dashboard" end end end

report = Analytics::Report.new dashboard = Analytics::Dashboard.new

Module Include vs Prepend vs Extend

module Greetable def greet "Hello from Greetable" end end

class Person def greet "Hello from Person" end end

include - adds module methods as instance methods (after class methods in lookup chain)

class Person include Greetable end Person.new.greet # => "Hello from Person" (class method takes precedence)

prepend - adds module methods BEFORE class methods in lookup chain

class Person prepend Greetable end Person.new.greet # => "Hello from Greetable" (module takes precedence)

extend - adds module methods as CLASS methods

class Person extend Greetable end Person.greet # => "Hello from Greetable" (class method) Person.new.greet # NoMethodError

Method Lookup Chain

module A def who_am_i "A" end end

module B def who_am_i "B" end end

class C prepend A include B

def who_am_i "C" end end

C.ancestors # => [A, C, B, Object, Kernel, BasicObject] C.new.who_am_i # => "A" (prepended module wins)

Advanced Ruby OOP

Metaprogramming

define_method

class DynamicMethods [:first_name, :last_name, :email].each do |attribute| define_method(attribute) do instance_variable_get("@#{attribute}") end

define_method("#{attribute}=") do |value|
  instance_variable_set("@#{attribute}", value)
end

end end

user = DynamicMethods.new user.first_name = "Alice" user.first_name # => "Alice"

method_missing

class DynamicFinder def initialize(data) @data = data end

def method_missing(method_name, *args) if method_name.to_s.start_with?('find_by_') attribute = method_name.to_s.sub('find_by_', '') @data.find { |item| item[attribute.to_sym] == args.first } else super end end

def respond_to_missing?(method_name, include_private = false) method_name.to_s.start_with?('find_by_') || super end end

users = DynamicFinder.new([ { name: 'Alice', email: 'alice@example.com' }, { name: 'Bob', email: 'bob@example.com' } ])

users.find_by_name('Alice') # => { name: 'Alice', email: 'alice@example.com' } users.find_by_email('bob@example.com') # => { name: 'Bob', email: 'bob@example.com' }

class_eval and instance_eval

class_eval - evaluates code in context of class

User.class_eval do def new_method "defined dynamically" end end

instance_eval - evaluates code in context of instance

user = User.new user.instance_eval do @secret = "secret value" end

Eigenclass (Singleton Class)

class Person def self.species "Homo sapiens" end end

Equivalent using eigenclass

class Person class << self def species "Homo sapiens" end end end

Adding methods to eigenclass of instance

person = Person.new class << person def special_ability "Can fly" end end

person.special_ability # Works Person.new.special_ability # NoMethodError

Rails-Specific OOP

ActiveSupport::Concern

Traditional module

module Taggable def self.included(base) base.extend(ClassMethods) base.class_eval do has_many :tags, as: :taggable end end

module ClassMethods def with_tag(tag_name) joins(:tags).where(tags: { name: tag_name }) end end

def tag_names tags.pluck(:name) end end

Using ActiveSupport::Concern (cleaner)

module Taggable extend ActiveSupport::Concern

included do has_many :tags, as: :taggable end

class_methods do def with_tag(tag_name) joins(:tags).where(tags: { name: tag_name }) end end

def tag_names tags.pluck(:name) end end

Usage

class Article < ApplicationRecord include Taggable end

Article.with_tag('ruby') # Class method article.tag_names # Instance method

Service Objects

Service object for complex business logic

class CreateOrderService def initialize(user, cart) @user = user @cart = cart end

def call validate_cart!

ActiveRecord::Base.transaction do
  @order = create_order
  create_order_items
  charge_payment
  send_confirmation
  clear_cart
end

Result.success(@order)

rescue => e Result.failure(e.message) end

private

def validate_cart! raise "Cart is empty" if @cart.items.empty? raise "Cart total invalid" unless @cart.total_valid? end

def create_order @user.orders.create!(total: @cart.total, status: 'pending') end

def create_order_items @cart.items.each do |cart_item| @order.order_items.create!( product: cart_item.product, quantity: cart_item.quantity, price: cart_item.price ) end end

def charge_payment PaymentService.charge(@user, @cart.total) end

def send_confirmation OrderMailer.confirmation(@order).deliver_later end

def clear_cart @cart.clear! end end

Result object

class Result attr_reader :value, :error

def initialize(success, value, error = nil) @success = success @value = value @error = error end

def self.success(value) new(true, value) end

def self.failure(error) new(false, nil, error) end

def success? @success end

def failure? !@success end end

Usage

result = CreateOrderService.new(user, cart).call if result.success? redirect_to order_path(result.value) else flash[:error] = result.error redirect_to cart_path end

Form Objects

class UserRegistrationForm include ActiveModel::Model include ActiveModel::Attributes

attribute :email, :string attribute :password, :string attribute :password_confirmation, :string attribute :first_name, :string attribute :last_name, :string attribute :accept_terms, :boolean

validates :email, presence: true, format: { with: URI::MailTo::EMAIL_REGEXP } validates :password, presence: true, length: { minimum: 8 } validates :password_confirmation, presence: true validates :first_name, :last_name, presence: true validates :accept_terms, acceptance: true

validate :passwords_match

def save return false unless valid?

ActiveRecord::Base.transaction do
  @user = User.create!(
    email: email,
    password: password,
    first_name: first_name,
    last_name: last_name
  )

  @profile = @user.create_profile!
  send_welcome_email
end

true

rescue => e errors.add(:base, e.message) false end

attr_reader :user

private

def passwords_match if password != password_confirmation errors.add(:password_confirmation, "doesn't match password") end end

def send_welcome_email UserMailer.welcome(@user).deliver_later end end

Usage in controller

def create @form = UserRegistrationForm.new(registration_params)

if @form.save redirect_to dashboard_path else render :new end end

Query Objects

class ActiveUsersQuery def initialize(relation = User.all) @relation = relation end

def call @relation .where(active: true) .where('last_login_at > ?', 30.days.ago) .order(last_login_at: :desc) end

Chainable query methods

def with_subscription @relation = @relation.joins(:subscription).where.not(subscriptions: { expires_at: nil }) self end

def by_role(role) @relation = @relation.where(role: role) self end end

Usage

ActiveUsersQuery.new.call ActiveUsersQuery.new.with_subscription.call ActiveUsersQuery.new.by_role('admin').with_subscription.call

Policy Objects (Pundit)

app/policies/post_policy.rb

class PostPolicy attr_reader :user, :post

def initialize(user, post) @user = user @post = post end

def index? true end

def show? post.published? || post.author == user || user&.admin? end

def create? user.present? end

def update? post.author == user || user&.admin? end

def destroy? post.author == user || user&.admin? end

def publish? (post.author == user && post.draft?) || user&.admin? end

class Scope attr_reader :user, :scope

def initialize(user, scope)
  @user = user
  @scope = scope
end

def resolve
  if user&.admin?
    scope.all
  elsif user
    scope.where(published: true).or(scope.where(author: user))
  else
    scope.where(published: true)
  end
end

end end

Usage

authorize @post # Calls PostPolicy#show? @posts = policy_scope(Post) # Calls PostPolicy::Scope#resolve

Presenter/Decorator Objects

class UserPresenter def initialize(user, view_context) @user = user @view = view_context end

def full_name [@user.first_name, @user.last_name].join(' ') end

def avatar_url @user.avatar.attached? ? @view.url_for(@user.avatar) : @view.asset_path('default_avatar.png') end

def formatted_created_at @view.time_ago_in_words(@user.created_at) + " ago" end

def profile_link @view.link_to(full_name, @view.user_path(@user)) end

Delegate unknown methods to user

def method_missing(method, *args, &block) @user.send(method, *args, &block) end

def respond_to_missing?(method, include_private = false) @user.respond_to?(method, include_private) || super end end

Using Draper gem (recommended)

class UserDecorator < Draper::Decorator delegate_all

def full_name [object.first_name, object.last_name].join(' ') end

def avatar_url object.avatar.attached? ? h.url_for(object.avatar) : h.asset_path('default_avatar.png') end

def formatted_created_at h.time_ago_in_words(object.created_at) + " ago" end end

Usage

@user = User.find(params[:id]).decorate @user.full_name @user.formatted_created_at

Value Objects

class Money include Comparable

attr_reader :amount, :currency

def initialize(amount, currency = 'USD') @amount = BigDecimal(amount.to_s) @currency = currency end

def +(other) raise ArgumentError, "Currency mismatch" unless currency == other.currency Money.new(amount + other.amount, currency) end

def -(other) raise ArgumentError, "Currency mismatch" unless currency == other.currency Money.new(amount - other.amount, currency) end

def *(multiplier) Money.new(amount * multiplier, currency) end

def <=>(other) return nil unless currency == other.currency amount <=> other.amount end

def ==(other) other.is_a?(Money) && amount == other.amount && currency == other.currency end alias eql? ==

def hash [amount, currency].hash end

def to_s format("%.2f %s", amount, currency) end end

Usage

price = Money.new(29.99, 'USD') tax = Money.new(2.10, 'USD') total = price + tax # => Money object total.to_s # => "32.09 USD"

SOLID Principles in Ruby

Single Responsibility Principle (SRP)

Each class should have one reason to change.

BAD - Multiple responsibilities

class User def create # Database logic ActiveRecord::Base.connection.execute("INSERT INTO users...")

# Email logic
send_welcome_email

# Analytics logic
track_signup_event

end end

GOOD - Separated responsibilities

class User < ApplicationRecord after_create :send_welcome_email after_create :track_signup

private

def send_welcome_email UserMailer.welcome(self).deliver_later end

def track_signup AnalyticsService.track_event(self, 'signup') end end

class UserMailer < ApplicationMailer def welcome(user) # Email logic end end

class AnalyticsService def self.track_event(user, event_name) # Analytics logic end end

Open/Closed Principle (OCP)

Open for extension, closed for modification.

BAD - Must modify class to add payment methods

class PaymentProcessor def process(payment_method, amount) case payment_method when 'credit_card' process_credit_card(amount) when 'paypal' process_paypal(amount) when 'bitcoin' process_bitcoin(amount) end end end

GOOD - Open for extension via polymorphism

class PaymentProcessor def process(payment_method, amount) payment_method.process(amount) end end

class CreditCardPayment def process(amount) # Credit card processing end end

class PaypalPayment def process(amount) # PayPal processing end end

class BitcoinPayment def process(amount) # Bitcoin processing end end

Usage

processor = PaymentProcessor.new processor.process(CreditCardPayment.new, 100) processor.process(PaypalPayment.new, 100)

Liskov Substitution Principle (LSP)

Subclasses should be substitutable for their base classes.

BAD - Breaks LSP

class Rectangle attr_accessor :width, :height

def area width * height end end

class Square < Rectangle def width=(value) super @height = value end

def height=(value) super @width = value end end

This breaks expectations:

rect = Square.new rect.width = 5 rect.height = 10 rect.area # => 100 (expected 50)

GOOD - Composition over inheritance

class Rectangle attr_accessor :width, :height

def area width * height end end

class Square attr_reader :side

def initialize(side) @side = side end

def area side * side end end

Interface Segregation Principle (ISP)

Clients shouldn't depend on interfaces they don't use.

BAD - Fat interface

module Worker def work raise NotImplementedError end

def eat raise NotImplementedError end

def sleep raise NotImplementedError end end

class Human include Worker

def work; end def eat; end def sleep; end end

class Robot include Worker

def work; end def eat; raise "Robots don't eat"; end def sleep; raise "Robots don't sleep"; end end

GOOD - Segregated interfaces

module Workable def work raise NotImplementedError end end

module Eatable def eat raise NotImplementedError end end

module Sleepable def sleep raise NotImplementedError end end

class Human include Workable include Eatable include Sleepable

def work; end def eat; end def sleep; end end

class Robot include Workable

def work; end end

Dependency Inversion Principle (DIP)

Depend on abstractions, not concretions.

BAD - Direct dependency on concrete class

class OrderProcessor def process(order) notifier = EmailNotifier.new notifier.send(order.customer.email, "Order processed") end end

GOOD - Dependency injection

class OrderProcessor def initialize(notifier) @notifier = notifier end

def process(order) @notifier.send(order.customer.email, "Order processed") end end

class EmailNotifier def send(email, message) # Send email end end

class SmsNotifier def send(phone, message) # Send SMS end end

Usage

email_processor = OrderProcessor.new(EmailNotifier.new) sms_processor = OrderProcessor.new(SmsNotifier.new)

Inheritance Patterns

Single Table Inheritance (STI)

app/models/vehicle.rb

class Vehicle < ApplicationRecord

Table: vehicles

Columns: id, type, name, max_speed, max_altitude, max_depth

end

class Car < Vehicle def drive "Driving at #{max_speed} mph" end end

class Airplane < Vehicle def fly "Flying at #{max_altitude} ft" end end

class Submarine < Vehicle def dive "Diving to #{max_depth} ft" end end

Usage

car = Car.create(name: 'Tesla', max_speed: 150) airplane = Airplane.create(name: 'Boeing 747', max_altitude: 45000)

Vehicle.all # Returns mix of Cars, Airplanes, Submarines Car.all # Returns only Cars

When to use STI:

• Subclasses share most attributes

• Subclasses have similar behavior

• Need to query across all types

STI Anti-patterns:

• Too many type-specific columns (use delegated_type instead)

• Vastly different behavior between types

• Deep inheritance hierarchies

Delegated Type (Rails 6.1+)

Better than STI when types have different attributes

class Entry < ApplicationRecord delegated_type :entryable, types: %w[Message Comment] end

class Message < ApplicationRecord has_one :entry, as: :entryable, touch: true end

class Comment < ApplicationRecord has_one :entry, as: :entryable, touch: true end

Usage

entry = Entry.find(1) entry.entryable # Returns Message or Comment entry.message? # true if type is Message entry.comment? # true if type is Comment

Polymorphic Associations

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

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

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

Usage

article = Article.find(1) article.comments.create(body: "Great article!")

video = Video.find(1) video.comments.create(body: "Great video!")

Composition Over Inheritance

Delegation with Forwardable

require 'forwardable'

class Order extend Forwardable

def_delegators :@customer, :name, :email, :phone def_delegators :@line_items, :<<, :each, :size

def initialize(customer) @customer = customer @line_items = [] end end

order = Order.new(customer) order.name # Delegates to customer.name order << line_item # Delegates to line_items.<<

SimpleDelegator

require 'delegate'

class UserDecorator < SimpleDelegator def full_name "#{first_name} #{last_name}" end

def greeting "Hello, #{full_name}!" end end

user = User.new(first_name: 'Alice', last_name: 'Smith') decorated = UserDecorator.new(user) decorated.full_name # => "Alice Smith" decorated.email # Delegates to user.email

ActiveSupport::Delegation

class Order delegate :name, :email, to: :customer, prefix: true delegate :total_price, to: :calculator

def initialize(customer, items) @customer = customer @items = items end

private

def calculator @calculator ||= PriceCalculator.new(@items) end end

order.customer_name # => customer.name order.customer_email # => customer.email order.total_price # => calculator.total_price

Modern Ruby Features

Pattern Matching (Ruby 3.x)

def process_response(response) case response in { status: 200, body: } puts "Success: #{body}" in { status: 404 } puts "Not found" in { status: 500..599, error: } puts "Server error: #{error}" else puts "Unknown response" end end

Array pattern matching

def process_coordinates(point) case point in [0, 0] "Origin" in [x, 0] "On X axis at #{x}" in [0, y] "On Y axis at #{y}" in [x, y] "Point at (#{x}, #{y})" end end

Endless Methods (Ruby 3.x)

Traditional

def full_name "#{first_name} #{last_name}" end

Endless method

def full_name = "#{first_name} #{last_name}"

With arguments

def greet(name) = "Hello, #{name}!"

Useful for simple one-liners

def adult? = age >= 18 def total = items.sum(&:price)

Keyword Arguments

Required keyword arguments

def create_user(email:, password:, role: 'member') User.create(email: email, password: password, role: role) end

create_user(email: 'user@example.com', password: 'secret')

**kwargs for flexibility

def build_query(**options) options.each do |key, value| puts "#{key}: #{value}" end end

build_query(name: 'Alice', age: 30, city: 'NYC')

Numbered Parameters

Traditional

users.map { |user| user.name.upcase }

Numbered parameters (Ruby 2.7+)

users.map { _1.name.upcase }

Multiple parameters

users.zip(posts).map { "#{_1.name}: #{_2.title}" }

Testing OOP Code

Testing Private Methods

Generally, don't test private methods directly

Test through public interface instead

class Calculator def calculate(numbers) validate_input(numbers) sum(numbers) end

private

def validate_input(numbers) raise ArgumentError unless numbers.is_a?(Array) end

def sum(numbers) numbers.sum end end

Test public method (which exercises private methods)

RSpec.describe Calculator do describe '#calculate' do it 'calculates sum' do expect(subject.calculate([1, 2, 3])).to eq(6) end

it 'validates input' do
  expect { subject.calculate("invalid") }.to raise_error(ArgumentError)
end

end end

If you MUST test private method

RSpec.describe Calculator do describe '#sum' do it 'sums numbers' do expect(subject.send(:sum, [1, 2, 3])).to eq(6) end end end

Testing Modules

module Taggable def add_tag(tag) @tags ||= [] @tags << tag end

def tags @tags || [] end end

Create dummy class for testing

RSpec.describe Taggable do let(:dummy_class) { Class.new { include Taggable } } let(:instance) { dummy_class.new }

describe '#add_tag' do it 'adds tag' do instance.add_tag('ruby') expect(instance.tags).to include('ruby') end end end

Mocking and Stubbing

RSpec.describe OrderProcessor do describe '#process' do let(:order) { double('Order', id: 1, total: 100) } let(:payment_gateway) { double('PaymentGateway') } subject { OrderProcessor.new(payment_gateway) }

it 'charges payment' do
  expect(payment_gateway).to receive(:charge).with(100)
  subject.process(order)
end

it 'handles payment failure' do
  allow(payment_gateway).to receive(:charge).and_raise(PaymentError)
  expect { subject.process(order) }.to raise_error(PaymentError)
end

end end

Rails Anti-Patterns

Fat Models

BAD - Fat model with too many responsibilities

class User < ApplicationRecord def create_with_profile(params) # Creation logic end

def send_welcome_email # Email logic end

def calculate_statistics # Analytics logic end

def export_to_csv # Export logic end end

GOOD - Thin model with extracted services

class User < ApplicationRecord

Only model-specific logic and validations

validates :email, presence: true, uniqueness: true has_many :posts end

class UserCreationService def call(params) # Creation logic end end

class UserStatisticsService def call(user) # Analytics logic end end

class UserCsvExporter def export(users) # Export logic end end

Callback Hell

BAD - Too many callbacks

class Order < ApplicationRecord before_validation :set_defaults after_validation :check_inventory before_create :generate_order_number after_create :send_confirmation after_create :update_inventory after_create :create_invoice after_create :notify_warehouse after_update :log_changes before_destroy :cancel_pending_shipments end

GOOD - Explicit service object

class CreateOrderService def call(params) order = Order.new(params) order.set_defaults

return Result.failure(order.errors) unless order.valid?

ActiveRecord::Base.transaction do
  order.generate_order_number
  order.save!

  send_confirmation(order)
  update_inventory(order)
  create_invoice(order)
  notify_warehouse(order)
end

Result.success(order)

end end

God Objects

BAD - One object does everything

class ApplicationController < ActionController::Base def current_user # User logic end

def authorize_admin # Authorization logic end

def log_action(action) # Logging logic end

def send_notification(message) # Notification logic end

def format_date(date) # Formatting logic end end

GOOD - Separated concerns

class ApplicationController < ActionController::Base include Authentication include Authorization include Logging end

module Authentication def current_user @current_user ||= User.find_by(id: session[:user_id]) end end

module Authorization def authorize_admin redirect_to root_path unless current_user&.admin? end end

Summary Checklist

Good OOP Practices:

• Use meaningful class and method names

• Keep classes focused (Single Responsibility Principle)

• Prefer composition over inheritance

• Use modules for shared behavior

• Make dependencies explicit (dependency injection)

• Write tests for public interfaces

• Use service objects for complex business logic

• Use form objects for complex forms

• Use query objects for complex queries

• Use presenters/decorators for view logic

• Follow SOLID principles

• Avoid callback hell - use service objects

• Avoid fat models - extract to services

• Use value objects for domain concepts

This skill provides comprehensive OOP patterns for Ruby and Rails development!