Arrays & Hashes

Arrays and Hashes are two of the most important data structures in Ruby. They help developers organize, store, and manage data efficiently in applications.

Arrays are used for storing ordered collections of values, while Hashes store data in key-value pairs. Both are heavily used in Ruby programming, web development, APIs, and database operations.

Arrays

An Array is a collection of multiple values stored inside a single variable. Each element inside the array has an index position starting from 0.

Arrays can store numbers, strings, objects, or even other arrays.

arr = [1, 2, 3, 4, 5]

arr << 6

arr.each { |n| puts n }

arr.map { |n| n * 2 }

arr.select { |n| n.even? }

In this example:

• [1, 2, 3, 4, 5] creates an array
• << adds a new element to the array
• each loops through every element
• map transforms array values
• select filters elements based on conditions

Accessing Array Elements

Array elements can be accessed using index positions. Remember that indexing starts from zero.

fruits = ["Apple", "Banana", "Orange"]

puts fruits[0]
puts fruits[1]

Output:

Apple
Banana

Here:

• fruits[0] accesses the first element
• fruits[1] accesses the second element

Adding and Removing Elements

Ruby provides several methods for modifying arrays dynamically.

numbers = [1, 2, 3]

numbers.push(4)

numbers.pop

puts numbers.inspect

Explanation:

• push() adds an element to the end of the array
• pop removes the last element
• inspect displays the complete array

Looping Through Arrays

Looping allows us to process each element individually. Ruby provides elegant iteration methods for arrays.

colors = ["Red", "Green", "Blue"]

colors.each do |color|
  puts color
end

The each method is one of the most commonly used iteration methods in Ruby.

Transforming Arrays with map()

The map() method creates a new array by modifying each element.

numbers = [1, 2, 3]

doubled = numbers.map { |n| n * 2 }

puts doubled.inspect

Output:

[2, 4, 6]

Filtering Arrays with select()

The select() method filters elements based on conditions.

numbers = [1, 2, 3, 4, 5]

evens = numbers.select { |n| n.even? }

puts evens.inspect

Output:

[2, 4]

Hashes

A Hash is a collection of key-value pairs. Instead of numeric indexes, data is accessed using unique keys.

Hashes are extremely useful for storing structured data such as user profiles, configuration settings, and JSON-like objects.

user = { name: "Ahmed", age: 25 }

user[:city] = "Cairo"

user.each { |k, v| puts "#{k}: #{v}" }

In this example:

• name and age are keys
• "Ahmed" and 25 are values
• user[:city] adds a new key-value pair
• each iterates through the hash

Accessing Hash Values

Hash values are accessed using keys.

student = {
  name: "Sara",
  marks: 92
}

puts student[:name]
puts student[:marks]

Output:

Sara
92

Updating Hashes

Hash values can easily be updated or modified.

user = { name: "Ali", age: 20 }

user[:age] = 21

puts user.inspect

The age value changes from 20 to 21.

Nested Arrays and Hashes

Ruby allows arrays and hashes to be nested inside each other for more complex data structures.

students = [
  { name: "Ahmed", grade: 90 },
  { name: "Sara", grade: 85 }
]

puts students[0][:name]

This structure is commonly used in APIs and database records.

Advantages of Arrays & Hashes

• Efficient data organization
• Easy data access and modification
• Flexible storage structures
• Useful for real-world applications
• Essential for Ruby and Rails development

Best Practices

• Use arrays for ordered collections
• Use hashes for structured key-value data
• Choose meaningful key names
• Avoid deeply nested structures when possible
• Use iteration methods for cleaner code

Summary

In this lecture, we learned about Arrays and Hashes in Ruby. We explored how arrays store ordered collections and how hashes store data using key-value pairs.

We also learned how to access, modify, transform, and filter data using methods like each, map, and select.

Arrays and Hashes are foundational concepts used throughout Ruby programming and Ruby on Rails development.

Strings & Regular Expressions

Strings are one of the most commonly used data types in programming. Almost every application works with text in some form — usernames, passwords, emails, search queries, messages, logs, and file content.

Ruby provides powerful built-in string methods that make text processing simple and efficient. Along with strings, Ruby also supports Regular Expressions (Regex), which allow developers to search, validate, and manipulate text patterns.

In this lecture, we will learn:

• How to work with strings in Ruby
• Important string methods
• How string manipulation works
• What regular expressions are
• How regex is used for validation and searching

String Methods

Ruby strings come with many built-in methods for modifying and analyzing text. These methods help developers process data quickly without writing complex logic.

s = "Hello Ruby"

# Convert to uppercase
puts s.upcase

# Convert to lowercase
puts s.downcase

# Reverse string
puts s.reverse

# String length
puts s.length

# Replace text
puts s.gsub("Ruby", "World")

# Split into array
p s.split(" ")

Understanding Important String Methods

• upcase converts text to uppercase
• downcase converts text to lowercase
• reverse reverses characters
• length returns total characters
• gsub replaces text globally
• split breaks string into arrays

More Useful String Methods

Ruby includes many additional methods for checking and manipulating text.

text = "  Ruby Language  "

# Remove spaces
puts text.strip

# Check substring
puts text.include?("Ruby")

# Start and end checks
puts text.start_with?(" ")
puts text.end_with?(" ")

# Repeat string
puts "Hi! " * 3

# Access characters
puts text[2]
puts text[0, 5]

String Interpolation

String interpolation allows variables to be inserted directly inside strings using #{ }.

This is cleaner and easier than concatenation.

name = "Ahmed"
age = 22

puts "My name is #{name}"
puts "I am #{age} years old"

Regular Expressions (Regex)

Regular Expressions are patterns used to search, match, and validate text. Regex is extremely useful for checking formats like emails, phone numbers, passwords, URLs, and dates.

Ruby provides excellent built-in support for regex.

# Match digits
puts "abc123" =~ /\d+/

# Email validation
puts "a@b.com".match?(/\A[\w.]+@[\w]+\.\w+\z/)

# Find all matches
p "hello".scan(/l/)

Understanding Regex Symbols

• \d → Any digit
• + → One or more matches
• \A → Start of string
• \z → End of string
• [] → Character group
• . → Any character

Regex Matching Methods

Ruby provides several methods for regex operations.

text = "Ruby 123 Programming"

# Check match
puts text.match?(/\d+/)

# Return first match
p text.match(/\d+/)

# Find all matches
p text.scan(/\w+/)

# Replace using regex
puts text.gsub(/\d+/, "***")

Email Validation Example

Regex is commonly used for validating user input in forms and applications.

email = "user@example.com"

pattern = /\A[\w.]+@[\w]+\.\w+\z/

if email.match?(pattern)
  puts "Valid Email"
else
  puts "Invalid Email"
end

Phone Number Validation

Regex can also validate phone number formats.

phone = "9876543210"

if phone.match?(/\A\d{10}\z/)
  puts "Valid Number"
else
  puts "Invalid Number"
end

Common Regex Patterns

# Only digits
/\d+/

# Only alphabets
/[a-zA-Z]+/

# Whitespace
/\s/

# Email format
/\A[\w.]+@[\w]+\.\w+\z/

# 10-digit phone number
/\A\d{10}\z/

Best Practices

• Use meaningful regex patterns
• Keep regex readable and simple
• Use string methods before complex regex when possible
• Validate user input carefully
• Test regex patterns with multiple examples

OOP in Ruby

Object-Oriented Programming (OOP) is a programming paradigm that organizes code using objects and classes. Ruby is a fully object-oriented language, meaning almost everything in Ruby is treated as an object.

OOP helps developers write cleaner, reusable, scalable, and maintainable code. It is widely used in Ruby on Rails applications and modern software development.

What is a Class?

A class is a blueprint or template used to create objects. It defines the properties (attributes) and behaviors (methods) that objects will have.

For example:

• A Car class may contain color, speed, and brand
• A User class may contain name, email, and password
• A BankAccount class may contain balance and account number

Classes

class Person

  attr_accessor :name, :age

  def initialize(name, age)
    @name = name
    @age = age
  end

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

p = Person.new("Ahmed", 25)

puts p.greet

In this example:

• class Person defines a new class
• attr_accessor creates getter and setter methods
• initialize is the constructor method
• @name and @age are instance variables
• Person.new() creates a new object
• greet is an instance method

Understanding Objects

An object is an instance of a class. When we create an object, Ruby allocates memory and stores the object's data separately.

car1 = Person.new("Ali", 22)

car2 = Person.new("Sara", 21)

puts car1.name
puts car2.name

Each object maintains its own independent data.

Instance Variables

Instance variables store object-specific data. They begin with the @ symbol.

class Student

  def initialize(name)
    @name = name
  end

  def show
    puts @name
  end
end

The variable @name belongs to each individual object.

Methods in Ruby

Methods define the behavior of objects. They allow objects to perform actions.

class Calculator

  def add(a, b)
    a + b
  end
end

calc = Calculator.new

puts calc.add(5, 3)

Output:

8

Accessors in Ruby

Ruby provides special helper methods for managing object attributes.

• attr_reader → Read-only access
• attr_writer → Write-only access
• attr_accessor → Read and write access

class User

  attr_accessor :username

  def initialize(username)
    @username = username
  end
end

Inheritance

Inheritance allows one class to inherit properties and methods from another class. This promotes code reusability and reduces duplication.

class Animal

  def speak = "..."
end

class Dog < Animal

  def speak = "Woof!"
end

In this example:

• Dog inherits from Animal
• The speak method is overridden inside Dog
• This demonstrates polymorphism in Ruby

Method Overriding

Method overriding occurs when a child class provides its own version of a parent class method.

class Vehicle

  def move
    puts "Moving..."
  end
end

class Bike < Vehicle

  def move
    puts "Bike is moving"
  end
end

Using super

The super keyword calls a method from the parent class.

class Animal

  def speak
    puts "Animal sound"
  end
end

class Cat < Animal

  def speak
    super
    puts "Meow"
  end
end

Output:

Animal sound
Meow

Encapsulation

Encapsulation means hiding internal object details and exposing only necessary functionality. It improves security and protects object data.

class Account

  def show_balance
    puts calculate_balance
  end

  private

  def calculate_balance
    5000
  end
end

Private methods can only be accessed inside the same class.

Advantages of OOP

• Improves code organization
• Encourages code reusability
• Makes large applications easier to manage
• Supports modular development
• Reduces duplicate code

Real-World Uses of OOP

• Web applications
• Game development
• Banking systems
• E-commerce platforms
• Social media applications
• Desktop software

Best Practices

• Use meaningful class names
• Keep classes focused on one responsibility
• Avoid unnecessary inheritance
• Use encapsulation to protect data
• Write reusable methods

Summary

In this lecture, we learned the fundamentals of Object-Oriented Programming in Ruby. We explored classes, objects, methods, instance variables, and accessors.

We also studied inheritance, method overriding, encapsulation, and the use of the super keyword.

OOP is a foundational concept in Ruby and is heavily used in Ruby on Rails and modern software development.

Modules & Mixins

As Ruby applications grow larger, organizing code becomes extremely important. Writing everything inside a single file or class quickly becomes difficult to manage.

Ruby provides Modules and Mixins to help developers organize reusable code efficiently. Modules help group related functionality together, while mixins allow classes to share methods without inheritance.

These concepts are widely used in Ruby and Ruby on Rails applications because they improve:

• Code organization
• Reusability
• Maintainability
• Scalability

In this lecture, we will learn:

• What modules are
• How modules work as namespaces
• How to create reusable mixins
• How include works in Ruby
• How modules improve application structure

What is a Module?

A module is a container used to group related methods, constants, and classes together. Unlike classes, modules cannot create objects directly.

Modules are mainly used for:

• Creating namespaces
• Sharing reusable functionality
• Avoiding naming conflicts

Modules as Namespaces

Namespaces prevent naming conflicts between classes and methods. In large applications, different files may contain methods or classes with the same name.

Modules solve this problem by grouping related functionality together.

module MathTools

  # Module method
  def self.square(x)
    x * x
  end
end

puts MathTools.square(5)

Understanding the Example

• module MathTools creates a namespace
• self.square defines a module method
• MathTools.square(5) calls the method

Another Namespace Example

Multiple classes with the same name can exist safely inside different modules.

module Admin

  class User

    def info
      puts "Admin User"
    end
  end
end

module Customer

  class User

    def info
      puts "Customer User"
    end
  end
end

Admin::User.new.info

Customer::User.new.info

Why Namespaces Are Important

• Avoid duplicate names
• Improve project organization
• Group related functionality
• Keep code cleaner

Mixins

Mixins allow methods from a module to be included inside a class. This is one of Ruby’s most powerful features.

Instead of inheriting from another class, Ruby allows classes to reuse functionality through modules.

module Loggable

  def log(msg)
    puts "[LOG] #{msg}"
  end
end

class Service

  include Loggable

  def run
    log("Started")
  end
end

Service.new.run

Understanding Mixins

• Loggable contains reusable methods
• include adds module methods to the class
• Service can directly use the log() method

Benefits of Mixins

• Reduce duplicate code
• Share reusable behaviors
• Support cleaner architecture
• Avoid deep inheritance chains

Including Multiple Modules

A Ruby class can include multiple modules at the same time.

module Printer

  def print_data
    puts "Printing Data"
  end
end

module Scanner

  def scan_data
    puts "Scanning Data"
  end
end

class Machine

  include Printer
  include Scanner
end

m = Machine.new

m.print_data

m.scan_data

Using extend

Ruby also provides the extend keyword. While include adds methods as instance methods, extend adds methods as class methods.

module Greeting

  def hello
    puts "Hello"
  end
end

class Test

  extend Greeting
end

Test.hello

include vs extend

• include → Adds instance methods
• extend → Adds class methods

Ruby Built-in Mixins

Ruby includes several built-in modules that provide useful functionality.

class Product

  include Comparable

  attr_accessor :price

  def initialize(price)
    @price = price
  end

  def <=>(other)
    price <=> other.price
  end
end

p1 = Product.new(100)

p2 = Product.new(200)

puts p1 < p2

What is Comparable?

The Comparable module allows objects to be compared using operators like:

• <
• >
• <=
• >=
• ==

To use Comparable, a class must define the <=> spaceship operator.

Best Practices

• Use modules to organize related functionality
• Use mixins for reusable behaviors
• Avoid putting too many responsibilities in one module
• Prefer mixins over unnecessary inheritance
• Use namespaces in large projects

File I/O & Exceptions

Reading & Writing

File.read("input.txt")
File.readlines("input.txt").each { |l| puts l }
File.open("out.txt", "w") { |f| f.puts "Hello" }
File.open("out.txt", "a") { |f| f.puts "World" }

Exceptions

begin
  File.read("missing.txt")
rescue Errno::ENOENT => e
  puts "Not found: #{e}"
ensure
  puts "Done."
end

Metaprogramming

Dynamic Methods

class User
  [:name, :age, :email].each do |attr|
    define_method(attr) { instance_variable_get("@#{attr}") }
    define_method("#{attr}=") { |v| instance_variable_set("@#{attr}", v) }
  end
end

method_missing

class Ghost
  def method_missing(method, *args)
    puts "Called #{method} with #{args}"
  end
end

Gems & Bundler

Gemfile

source 'https://rubygems.org'
gem 'rails', '~> 7.0'
gem 'rspec', group: :test

Commands

gem install nokogiri
bundle install
bundle update
bundle exec rake test

Testing with RSpec

Basic Spec

require 'rspec'
describe Calculator do
  it "adds two numbers" do
    expect(Calculator.add(2, 3)).to eq(5)
  end
end

Mocks

api = double("API")
allow(api).to receive(:fetch).and_return("data")
expect(api.fetch).to eq("data")

Rails Basics

Create a Rails App

gem install rails
rails new blog
cd blog
rails server

MVC Pattern

Rails follows Model-View-Controller: Models talk to the DB, Controllers handle requests, Views render HTML/JSON.

Scaffold a Resource

rails generate scaffold Post title:string body:text
rails db:migrate
rails server

Models & ActiveRecord

Model Definition

class Post < ApplicationRecord
  belongs_to :user
  has_many :comments
  validates :title, presence: true, length: { minimum: 5 }
end

Queries

Post.all
Post.find(1)
Post.where(published: true).order(created_at: :desc)
Post.create(title: "Hello", body: "World")
post.update(title: "New")
post.destroy

Migrations

class AddAuthorToPosts < ActiveRecord::Migration[7.0]
  def change
    add_column :posts, :author, :string
  end
end

Controllers & Routes

Routes

Rails.application.routes.draw do
  root "posts#index"
  resources :posts
  get "/about", to: "pages#about"
end

Controller

class PostsController < ApplicationController
  def index = @posts = Post.all
  def show = @post = Post.find(params[:id])
  def create
    @post = Post.new(post_params)
    @post.save ? redirect_to(@post) : render(:new)
  end
  private
  def post_params
    params.require(:post).permit(:title, :body)
  end
end

APIs & Deployment

API Mode

rails new myapi --api
# Controllers return JSON automatically

class Api::PostsController < ApplicationController
  def index
    render json: Post.all
  end
  def create
    post = Post.create!(post_params)
    render json: post, status: :created
  end
end

Deploy to Heroku/Render

git push heroku main
heroku run rails db:migrate
heroku logs --tail

Capstone Project: Rails Blog

Project: Full Blog Platform

Build a complete Rails blog with authentication, posts, comments, tags, and admin dashboard.

Features

• User auth (Devise gem)
• Posts with categories & tags
• Comments with nested replies
• Admin dashboard
• Rich text editor (ActionText)
• Image uploads (ActiveStorage)

Stack

gem 'rails', '~> 7.0'
gem 'devise'
gem 'pg'
gem 'image_processing'
gem 'rspec-rails', group: :test

Bonus

• Add markdown support with Redcarpet
• Add full-text search with pg_search
• Build a JSON API for mobile
• Deploy with Docker + CI/CD