The Art & Architecture of Ruby

$ irb
irb(main):001:0> "Hello World".reverse
=> "dlroW olleH"
irb(main):002:0> [1, 2, 3].sum
=> 6

# --- Variables and Dynamic Assignment ---
name = "Alice"         # String
age = 30               # Integer
is_active = true       # Boolean
price = 19.99          # Float

# --- Symbols ---
# Symbols are immutable, reusable identifiers represented with a leading colon.
# They are faster and use less memory than strings for hash keys.
status = :pending

# --- String Interpolation ---
# Double-quoted strings evaluate expressions inside #{...}
greeting = "Hello, #{name}! You are #{age} years old."
puts greeting

# --- Dynamic Methods on Everything ---
puts 42.class        # Output: Integer
puts :pending.class  # Output: Symbol
puts nil.nil?        # Output: true

# Array definition & transformation
numbers = [1, 2, 3, 4, 5]
doubled = numbers.map { |n| n * 2 }  # [2, 4, 6, 8, 10]

# Hash definition using Symbol syntax
user_profile = {
  name: "Elena",
  role: "Architect",
  experience: 8
}

puts user_profile[:role] # Outputs: "Architect"

# Standard If-Else Statement
score = 85
status = if score >= 90
           "A"
         elsif score >= 80
           "B"
         else
           "C"
         end

# Inline Statement Modifiers (Guard Clauses)
puts "Access granted" if score >= 80

# Unless: Opposite of If (Executes when condition is false)
logged_in = false
redirect_to_login unless logged_in

# Case / Pattern Matching
case score
when 90..100 then puts "Outstanding"
when 70..89  then puts "Acceptable"
else              puts "Needs Improvement"
end

# Passing a block using do...end
["Ruby", "Crystal", "Elixir"].each do |lang|
  puts "I love programming in #{lang}!"
end

# Custom method that yields control to a block
def benchmark
  start_time = Time.now
  yield if block_given?
  puts "Elapsed time: #{Time.now - start_time} seconds"
end

benchmark do
  sleep(0.1)
end

# --- Procs vs Lambdas ---
# A Lambda checks argument counts and handles returns locally.
my_lambda = ->(a, b) { a + b }
puts my_lambda.call(10, 20) # => 30

module Loggable
  def log(msg)
    puts "[LOG - #{Time.now.strftime('%H:%M:%S')}]: #{msg}"
  end
end

class BankAccount
  include Loggable

  attr_reader :owner, :balance

  def initialize(owner, initial_balance = 0)
    @owner = owner
    @balance = initial_balance
  end

  def deposit(amount)
    return if amount <= 0
    @balance += amount
    log("Deposited $#{amount}. New balance: $#{@balance}")
  end
end

account = BankAccount.new("Satoshi", 1000)
account.deposit(500)

# Intercepting undefined method calls via method_missing
class DynamicEntity
  def method_missing(method_name, *args)
    if method_name.to_s.start_with?("find_by_")
      field = method_name.to_s.sub("find_by_", "")
      puts "Executing SQL query: SELECT * FROM entities WHERE #{field} = '#{args.first}'"
    else
      super
    end
  end
end

entity = DynamicEntity.new
entity.find_by_email("user@domain.org")
# Output: Executing SQL query: SELECT * FROM entities WHERE email = 'user@domain.org'