Understanding Core Computer Language Concepts: Design Patterns, Polymorphism, and Object Relationships

=== Making Tea ===
Gathering ingredients...
Heating water to appropriate temperature...
Adding tea leaves to the infuser...
Steeping for 3-5 minutes...
Pouring into a cup...
=== Making Coffee ===
Gathering ingredients...
Heating water to appropriate temperature...
Adding ground coffee to the filter...
Brewing for 4-6 minutes...
Adding milk and sugar as desired, then pouring...

with Stacks;
procedure Use_Integer_Stack is
    package Int_Stacks is new Stacks(Item_Type => Integer, Max_Length => 100);
    My_Stack : Int_Stacks.Stack_Type;
begin
    Int_Stacks.Push(My_Stack, 42);
    -- ...
end Use_Integer_Stack;

# Ruby approach: Using blocks and duck typing
class Container
  def initialize
    @items = []
  end
  def add(item)
    @items << item
  end
  def process(&block)
    @items.each { |item| block.call(item) }
  end
  def map(&block)
    @items.map { |item| block.call(item) }
  end
  def select(&block)
    @items.select { |item| block.call(item) }
  end
end
# Using with different types
int_container = Container.new
int_container.add(1)
int_container.add(2)
int_container.add(3)
puts "Original integers:"
int_container.process { |x| puts x }
puts "\nDoubled integers:"
doubled = int_container.map { |x| x * 2 }
puts doubled.inspect
string_container = Container.new
string_container.add("Hello")
string_container.add("World")
string_container.add("Ruby")
puts "\nOriginal strings:"
string_container.process { |s| puts s }
puts "\nUppercased strings:"
uppercased = string_container.map { |s| s.upcase }
puts uppercased.inspect

# A more sophisticated generic-like pattern using modules
module Enumerable
  def filter_map(&block)
    map(&block).select { |item| !item.nil? }
  end
  def partition_by(&block)
    Hash.new { |h, k| h[k] = [] }.tap do |hash|
      each { |item| hash[block.call(item)] << item }
    end
  end
end
class MyList
  include Enumerable
  def initialize(items)
    @items = items
  end
  def each(&block)
    @items.each(&block)
  end
  def map(&block)
    @items.map(&block)
  end
  def select(&block)
    @items.select(&block)
  end
end
# Usage
numbers = MyList.new([1, 2, 3, 4, 5, 6])
evens = numbers.partition_by { |n| n.even? ? :even : :odd }
puts evens.inspect

# Strong aggregation: Car owns its parts
class Engine
  def initialize(horsepower)
    @horsepower = horsepower
  end
  def start
    puts "Engine with #{@horsepower}hp starting..."
  end
  def stop
    puts "Engine stopping..."
  end
end
class Wheel
  def initialize(size)
    @size = size
  end
  def rotate
    puts "#{@size}\" wheel rotating..."
  end
end
class Car
  def initialize(make, model)
    @make = make
    @model = model
    # Aggregation: Car contains Engine and Wheels
    @engine = Engine.new(200)
    @wheels = [
      Wheel.new(18),
      Wheel.new(18),
      Wheel.new(18),
      Wheel.new(18)
    ]
  end
  def start
    puts "Starting #{@make} #{@model}..."
    @engine.start
  end
  def drive
    @wheels.each(&:rotate)
    puts "Car is moving!"
  end
  def stop
    @engine.stop
    puts "Car stopped."
  end
end
# Usage
car = Car.new("Toyota", "Camry")
car.start
car.drive
car.stop

# Acquaintance: Order knows about Customer and Product
class Customer
  def initialize(name, email)
    @name = name
    @email = email
  end
  def name
    @name
  end
  def email
    @email
  end
end
class Product
  def initialize(name, price)
    @name = name
    @price = price
  end
  def name
    @name
  end
  def price
    @price
  end
end
class Order
  def initialize(order_id)
    @order_id = order_id
    @customer = nil  # Acquaintance: will know about a customer
    @products = []  # Acquaintance: will know about products
    @total = 0
  end
  # Receives a customer as a parameter
  def assign_customer(customer)
    @customer = customer
    puts "Order #{@order_id} assigned to #{customer.name}"
  end
  # Receives products as parameters
  def add_product(product, quantity = 1)
    @products << { product: product, quantity: quantity }
    @total += product.price * quantity
  end
  def display_summary
    puts "\n=== Order Summary ==="
    puts "Order ID: #{@order_id}"
    puts "Customer: #{@customer.name}"
    puts "Items:"
    @products.each do |item|
      puts "  - #{item[:product].name}: $#{item[:product].price} x #{item[:quantity]}"
    end
    puts "Total: $#{@total}"
  end
end
# Usage
customer = Customer.new("Alice Johnson", "alice@example.com")
product1 = Product.new("Laptop", 999)
product2 = Product.new("Mouse", 25)
order = Order.new("ORD-001")
order.assign_customer(customer)
order.add_product(product1)
order.add_product(product2, 2)
order.display_summary

# AGGREGATION: Restaurant owns its Menu and Tables
class MenuItem
  def initialize(name, price)
    @name = name
    @price = price
  end
  def description
    "#{@name}: $#{@price}"
  end
end
class Table
  def initialize(table_number, capacity)
    @table_number = table_number
    @capacity = capacity
    @is_occupied = false
  end
  def occupy
    @is_occupied = true
  end
  def free
    @is_occupied = false
  end
  def available?
    !@is_occupied
  end
end
class Menu
  def initialize(cuisine_type)
    @cuisine_type = cuisine_type
    @items = []
  end
  def add_item(item)
    @items << item
  end
  def list_items
    @items.map(&:description)
  end
end
class Restaurant
  def initialize(name)
    @name = name
    # AGGREGATION: Restaurant owns these objects
    @menu = Menu.new("Italian")
    @tables = [
      Table.new(1, 4),
      Table.new(2, 6),
      Table.new(3, 2)
    ]
  end
  def setup_menu
    @menu.add_item(MenuItem.new("Pasta Carbonara", 15))
    @menu.add_item(MenuItem.new("Lasagna", 18))
    @menu.add_item(MenuItem.new("Tiramisu", 8))
  end
  def show_menu
    puts "=== #{@name} Menu ==="
    @menu.list_items.each { |item| puts item }
  end
  def reserve_table(party_size)
    available_table = @tables.find { |t| t.available? && t.capacity >= party_size }
    if available_table
      available_table.occupy
      "Table reserved!"
    else
      "No suitable tables available"
    end
  end
end
# ACQUAINTANCE: Reservation knows about Customer and Restaurant
class Reservation
  def initialize(reservation_id)
    @reservation_id = reservation_id
    @customer = nil
    @restaurant = nil
    @time = nil
    @party_size = nil
  end
  def make_reservation(customer, restaurant, time, party_size)
    @customer = customer
    @restaurant = restaurant
    @time = time
    @party_size = party_size
    puts "Reservation #{@reservation_id} made for #{customer.name} at #{time} for #{party_size} people"
  end
  def confirm
    puts "Confirming reservation for #{@customer.name}..."
    result = @restaurant.reserve_table(@party_size)
    puts result
  end
end
# Usage
restaurant = Restaurant.new("Luigi's Italian Kitchen")
restaurant.setup_menu
restaurant.show_menu
customer = Customer.new("Bob Smith", "bob@example.com")
reservation = Reservation.new("RES-001")
reservation.make_reservation(customer, restaurant, "7:00 PM", 4)
reservation.confirm

# TEMPLATE METHOD: Base class for different user types
class LibraryUser
  def initialize(name)
    @name = name
    @borrowed_books = []
  end
  def process_checkout(book)
    check_eligibility
    check_availability(book)
    checkout_book(book)
    send_confirmation(book)
  end
  protected
  def check_eligibility
    raise NotImplementedError
  end
  def check_availability(book)
    puts "Checking if #{book.title} is available..."
  end
  def checkout_book(book)
    @borrowed_books << book
    puts "Book checked out successfully"
  end
  def send_confirmation(book)
    puts "Sending confirmation to #{@name}"
  end
end
class Student < LibraryUser
  def check_eligibility
    puts "Checking student ID and membership status..."
  end
  def send_confirmation(book)
    puts "Emailing confirmation to student: #{@name}"
  end
end
class Faculty < LibraryUser
  def check_eligibility
    puts "Checking faculty status..."
  end
  def checkout_book(book)
    @borrowed_books << book
    puts "Faculty member can borrow up to 20 items"
  end
end
# AGGREGATION: Library owns Books and has Shelves
class Book
  attr_reader :title, :author
  def initialize(title, author, isbn)
    @title = title
    @author = author
    @isbn = isbn
    @is_available = true
  end
  def available?
    @is_available
  end
  def checkout
    @is_available = false
  end
  def return_book
    @is_available = true
  end
end
class Shelf
  def initialize(section, capacity)
    @section = section
    @capacity = capacity
    @books = []
  end
  def add_book(book)
    @books << book if @books.length < @capacity
  end
  def list_books
    @books.map(&:title)
  end
end
class Library
  def initialize(name)
    @name = name
    # AGGREGATION: Library owns shelves and manages books
    @shelves = {
      fiction: Shelf.new("Fiction", 100),
      science: Shelf.new("Science", 100),
      history: Shelf.new("History", 100)
    }
    @all_books = []
  end
  def add_book(book, section)
    @all_books << book
    @shelves[section].add_book(book)
  end
  def find_book(title)
    @all_books.find { |book| book.title == title }
  end
end
# STRATEGY: Different checkout strategies
module CheckoutStrategy
  def apply_fee(days_borrowed)
    raise NotImplementedError
  end
end
class StudentCheckoutStrategy
  include CheckoutStrategy
  def apply_fee(days_borrowed)
    days_borrowed > 14 ? days_borrowed - 14 * 0.25 : 0
  end
end
class FacultyCheckoutStrategy
  include CheckoutStrategy
  def apply_fee(days_borrowed)
    days_borrowed > 30 ? (days_borrowed - 30) * 0.10 : 0
  end
end
class LateFeesCalculator
  def initialize(strategy)
    @strategy = strategy
  end
  def calculate(days_borrowed)
    @strategy.apply_fee(days_borrowed)
  end
  def change_strategy(strategy)
    @strategy = strategy
  end
end
# ACQUAINTANCE: Loan connects User and Book temporarily
class Loan
  def initialize(loan_id)
    @loan_id = loan_id
    @user = nil
    @book = nil
    @checkout_date = nil
  end
  def create_loan(user, book)
    @user = user
    @book = book
    @checkout_date = Date.today
    puts "Loan #{@loan_id}: #{user.class} borrowed '#{book.title}'"
  end
  def return_book
    days = (Date.today - @checkout_date).to_i
    fee_calculator = LateFeesCalculator.new(StudentCheckoutStrategy.new)
    fee = fee_calculator.calculate(days)
    puts "Book returned. Days borrowed: #{days}, Late fee: $#{fee}"
  end
end
# Usage demonstration
puts "=== Library Management System ==="
# Setup library (aggregation)
library = Library.new("City Public Library")
book1 = Book.new("The Ruby Way", "Hal Fulton", "ISBN001")
book2 = Book.new("Design Patterns", "Gang of Four", "ISBN002")
library.add_book(book1, :science)
library.add_book(book2, :fiction)
# User checkout with template method
student = Student.new("John Doe")
student.process_checkout(book1)
faculty = Faculty.new("Dr. Smith")
faculty.process_checkout(book2)
# Loan with acquaintance
loan1 = Loan.new("LOAN001")
loan1.create_loan(student, book1)
loan1.return_book