Ruby

Metaprogramming Example:

# Dynamic method generation with Ruby metaprogramming
class Product
  # Automatically create getter/setter methods
  attr_accessor :name, :price
  
  # Define methods dynamically based on a list
  ["available?", "discontinued?", "on_sale?"].each do |method_name|
    define_method(method_name) do
      # Implementation would vary based on the method
      status = method_name.to_s.chomp("?")
      instance_variable_get("@#{status}") == true
    end
  end
  
  # Method missing for dynamic property access
  def method_missing(method, *args)
    if method.to_s =~ /find_by_(.+)/
      attribute = $1
      self.class.all.find { |p| p.send(attribute) == args.first }
    else
      super
    end
  end
end
        

Core Syntax Elements:

# Expression orientation - everything returns a value
result = if x > 10
          "Greater"
        else
          "Lesser"
        end

# Statement modifiers for concise conditionals
puts "It's cold" if temperature < 0

# Method calls allow parentheses omission
puts "Hello"       # No parentheses
puts("Hello")      # With parentheses

# Built-in language constructs look like methods
5.times { |i| puts i }   # Iteration via method-like syntax
[1, 2, 3].map(&:to_s)    # Symbol-to-proc conversion

# Multiple return values without explicit tuples
def coordinates
  [x, y, z]
end
x, y, z = coordinates  # Parallel assignment
        

Ruby's Unique Syntactic Constructs:

# Case expressions with pattern matching (Ruby 2.7+)
case input
when [Integer, Integer] => [x, y]
  puts "Coordinates: #{x}, #{y}"
when String => name if name.start_with?("A")
  puts "Name starts with A: #{name}"
when { name: String => name, age: Integer => age }
  puts "Person: #{name}, #{age} years old"
else
  puts "Unrecognized pattern"
end

# Keyword arguments vs positional arguments
def configure(host:, port: 80, **options)
  # Named parameters with defaults and collection
end

# Block local variables
[1, 2, 3].each_with_index do |value, index; temp|
  # temp is local to this block
  temp = value * index
  puts temp
end
        

# Integer automatically handles arbitrary precision
factorial = 1
100.times { |i| factorial *= (i+1) }
puts factorial  # Massive number handled without overflow

# Float precision issues
0.1 + 0.2 == 0.3  # => false (returns 0.30000000000000004)

# Rational for exact arithmetic
r1 = Rational(1, 3)  # => (1/3)
r2 = Rational(2, 5)  # => (2/5)
r1 + r2  # => (11/15) - exact representation

# Complex numbers
c = Complex(2, 3)  # => (2+3i)
c * c  # => (2+3i)*(2+3i) = 4+12i-9 = (-5+12i)
        

# String encoding handling
str = "こんにちは"  # UTF-8 encoded by default
str.encoding  # => #<Encoding:UTF-8>
str.bytes     # => [227, 129, 147, 227, 130, 147, 227, 129, 171, 227, 129, 161, 227, 129, 175]

# String immutability comparison
str = "hello"
str_id = str.object_id
str << " world"  # Mutates in place
str.object_id == str_id  # => true (same object)

str = "hello"
str_id = str.object_id
str = str + " world"  # Creates new object
str.object_id == str_id  # => false (different object)
        

# Symbol internalization
sym1 = :status
sym2 = :status
sym1.object_id == sym2.object_id  # => true (same object in memory)

str1 = "status"
str2 = "status"
str1.object_id == str2.object_id  # => false (different objects)

# Memory usage comparison
require 'benchmark/memory'

Benchmark.memory do |x|
  x.report("10000 strings") { 
    10000.times.map { |i| "string_#{i}" }
  }
  
  x.report("10000 symbols") { 
    10000.times.map { |i| :"symbol_#{i}" }
  }
end
# Symbols consume less memory but are never garbage collected
        

# Array internals
# Ruby arrays resize exponentially to amortize reallocation costs
a = []
a.capacity  # Not a real method, but internally arrays have capacity > size

# Hash implementation changed in Ruby 2.0+ for improved DoS protection
# Ruby uses open addressing with quadratic probing instead of linked lists
h = {a: 1, b: 2}
h.compare_by_identity  # Changes comparison semantics to use object_id

# Performance characteristics
require 'benchmark'
n = 1_000_000
hash = Hash.new
array = []

n.times { |i| hash[i] = i; array[i] = i }

Benchmark.bm do |x|
  x.report("Hash lookup") { hash[n/2] }
  x.report("Array lookup") { array[n/2] }
end
# Hash lookup is O(1), array index lookup is also O(1)
        

# Numeric class hierarchy
# Numeric → Integer → (Fixnum/Bignum, now unified)
# Numeric → Float
# Numeric → Rational
# Numeric → Complex

# Automatic type conversion and precision handling
result = 1 / 2          # Integer division: 0
result = 1.0 / 2        # Float division: 0.5
result = Rational(1, 2) # Rational: (1/2)

# Arbitrary-precision arithmetic (seamless big number handling)
factorial = (1..100).inject(:*) # Computes 100! without overflow

# Numeric coercion protocol
# Ruby uses method_missing and coerce to handle mixed-type operations
class Dollars
  attr_reader :amount
  def initialize(amount)
    @amount = amount
  end
  
  def +(other)
    if other.is_a?(Dollars)
      Dollars.new(@amount + other.amount)
    else
      # Uses coercion protocol
      self + Dollars.new(other)
    end
  end
  
  def coerce(other)
    # Return [other_as_my_type, self] for a + b operations
    [Dollars.new(other), self]
  end
end

money = Dollars.new(100)
result = 50 + money  # Works via coercion protocol
        

# String implementation details
# - Mutable byte arrays with encoding metadata
# - Copy-on-write optimization (implementation dependent)
# - Ropes data structure in some Ruby implementations

# Encodings support
str = "こんにちは"
str.encoding         # => #<Encoding:UTF-8>
str.force_encoding("ASCII-8BIT")  # Changes the interpretation, not the bytes

# String interning and memory optimization
str1 = "hello".freeze   # Freezing prevents modification
str2 = "hello".freeze   # In Ruby 2.3+, identical frozen strings may share storage

# Performance comparison: string concatenation
require 'benchmark'

Benchmark.bm do |x|
  x.report("String#+") {
    s = ""
    10000.times { s = s + "x" }  # Creates 10000 intermediary strings
  }
  
  x.report("String#<<") {
    s = ""
    10000.times { s << "x" }     # Modifies in place, no intermediary strings
  }
  
  x.report("Array join") {
    a = []
    10000.times { a << "x" }
    s = a.join                   # Often more efficient for many pieces
  }
end

# String slicing with different parameters
str = "Ruby programming"
str[0]       # => "R" (single index returns character)
str[0, 4]    # => "Ruby" (index and length)
str[5..15]   # => "programming" (range)
str[/R.../]  # => "Ruby" (regex match)
str["Ruby"]  # => "Ruby" (substring match)
        

# Symbol table implementation
# - Global VM symbol table for uniqueness
# - Identity comparison is O(1) (pointer comparison)
# - Prior to Ruby 2.2, symbols were never garbage collected

# Performance comparison
require 'benchmark'

Benchmark.bm do |x|
  strings = Array.new(100000) { |i| "string_#{i}" }
  symbols = Array.new(100000) { |i| :"symbol_#{i}" }
  
  x.report("String comparison") {
    strings.each { |s| s == "string_50000" }
  }
  
  x.report("Symbol comparison") {
    symbols.each { |s| s == :symbol_50000 }
  }
end
# Symbol comparison is significantly faster due to pointer equality

# Symbol garbage collection in Ruby 2.2+
GC::INTERNAL_CONSTANTS[:SYMBOL_GC_ENABLE]  # => true in newer Ruby versions

# String to symbol risk analysis
user_input = "user_input"
sym = user_input.to_sym  # Can lead to memory exhaustion through symbol flooding in older Rubies
sym = user_input.intern   # Alias for to_sym

# Safer alternative in security-sensitive code
ALLOWED_KEYS = [:name, :email, :age]
user_input = "name"
sym = user_input.to_sym if ALLOWED_KEYS.include?(user_input.to_sym)
        

# Implementation details
# - Dynamically sized C array under the hood
# - Amortized O(1) append through over-allocation
# - Copy-on-write optimization in some Ruby implementations

# Performance characteristics by operation
# - Random access by index: O(1)
# - Insertion/deletion at beginning: O(n)
# - Insertion/deletion at end: Amortized O(1)
# - Search for value: O(n)

# Common algorithmic patterns
array = [5, 2, 8, 1, 9]

# Functional operations (non-mutating)
mapped = array.map { |x| x * 2 }        # [10, 4, 16, 2, 18]
filtered = array.select { |x| x > 5 }   # [8, 9]
reduced = array.reduce(0) { |sum, x| sum + x }  # 25

# Destructive operations (mutating)
array.sort!          # [1, 2, 5, 8, 9] - sorts in place
array.map! { |x| x * 2 }  # [2, 4, 10, 16, 18] - transforms in place

# Specialized array operations
flat = [1, [2, [3, 4]]].flatten  # [1, 2, 3, 4]
combos = [1, 2, 3].combination(2).to_a  # [[1, 2], [1, 3], [2, 3]]
transposed = [[1, 2], [3, 4]].transpose  # [[1, 3], [2, 4]]

# Memory optimizations
large_array = Array.new(1000000)  # Pre-allocate for known size
large_array = Array.new(1000000, 0)  # Fill with default value
large_array = Array.new(1000000) { |i| i }  # Initialize with block
        

# Hash implementation details
# - Prior to Ruby 2.0: MRI used separate chaining with linked lists
# - Ruby 2.0+: Open addressing with quadratic probing for DoS protection
# - Ruby preserves insertion order since 1.9

# Performance characteristics
# - Average lookup: O(1)
# - Worst-case lookup: O(n) (with hash collisions)
# - Ordered enumeration: O(n) in insertion order

# Hash functions and equality
class CustomKey
  attr_reader :id
  
  def initialize(id)
    @id = id
  end
  
  def hash
    # Good hash functions minimize collisions
    # and distribute values evenly
    @id.hash
  end
  
  def eql?(other)
    # Ruby uses eql? for hash key comparison
    self.class == other.class && @id == other.id
  end
end

# Default values
counter = Hash.new(0)  # Default value is 0
"hello".each_char { |c| counter[c] += 1 }  # Character frequency count

# Default value as block
fibonacci = Hash.new { |hash, key| 
  hash[key] = key <= 1 ? key : hash[key-1] + hash[key-2] 
}
fibonacci[100]  # Computes 100th Fibonacci number with memoization

# Performance comparison with different key types
require 'benchmark'

Benchmark.bm do |x|
  string_keys = Hash[Array.new(10000) { |i| ["key#{i}", i] }]
  symbol_keys = Hash[Array.new(10000) { |i| [:"key#{i}", i] }]
  
  x.report("String key lookup") {
    1000.times { string_keys["key5000"] }
  }
  
  x.report("Symbol key lookup") {
    1000.times { symbol_keys[:key5000] }
  }
end
# Symbol keys are generally faster due to optimized hash calculation
        

# One-line if (modifier form)
puts "Positive" if number > 0

# One-line unless (negative if)
puts "Not authorized" unless user.admin?

# Ternary operator
result = age >= 18 ? "Adult" : "Minor"

# If with assignment
if result = potentially_nil_method()
  # This condition is true if result is not nil
  # Be cautious - this is assignment (=), not comparison (==)
end
        

unless user.authenticated?
  redirect_to login_path
else
  grant_access
end
        

case input
when String
  puts "Input is a string"
when 1..100
  puts "Input is a number between 1 and 100"
when /^\d+$/
  puts "Input is a string of digits"
when ->(x) { x.respond_to?(:each) }
  puts "Input is enumerable"
else
  puts "Input is something else"
end
        

# Loop with break (infinite loop with explicit exit)
loop do
  print "Enter input (or 'q' to quit): "
  input = gets.chomp
  break if input == 'q'
  process(input)
end

# Next and redo for loop control
5.times do |i|
  next if i.even?  # Skip even numbers
  redo if rand > 0.8  # Sometimes repeat the same iteration
  puts i
end
        

# Each with block parameters
[1, 2, 3].each { |num| puts num * 2 }

# Map (transform values)
doubled = [1, 2, 3].map { |num| num * 2 } # => [2, 4, 6]

# Select (filter)
evens = (1..10).select { |num| num.even? } # => [2, 4, 6, 8, 10]

# Inject/reduce (accumulate)
sum = [1, 2, 3, 4].inject(0) { |acc, num| acc + num } # => 10

# Custom iterator example
def my_times(n)
  i = 0
  while i < n
    yield i
    i += 1
  end
end

my_times(3) { |i| puts "Iteration #{i}" }
        

Custom Iterator Implementation:

# A simplified implementation of the each method
class Array
  def my_each
    for i in 0...size
      yield(self[i])  # Transfer control to the block
    end
    self  # Return the original array (chainable)
  end
end

[1, 2, 3].my_each { |num| puts num }
        

# Internal iteration (Ruby-style)
[1, 2, 3].each { |num| puts num }

# External iteration (less common in Ruby)
iterator = [1, 2, 3].each
begin
  loop { puts iterator.next }
rescue StopIteration
  # End of iteration
end
        

# Implementation sketch of map
def map(enumerable)
  result = []
  enumerable.each do |element|
    result << yield(element)
  end
  result
end

# With lazy evaluation (Ruby 2.0+)
(1..Float::INFINITY).lazy.map { |n| n * 2 }.first(5)
# => [2, 4, 6, 8, 10]
        

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# select/find_all - returns all matching elements
numbers.select { |n| n % 3 == 0 }  # => [3, 6, 9]

# find/detect - returns first matching element
numbers.find { |n| n > 5 }  # => 6

# reject - opposite of select
numbers.reject { |n| n.even? }  # => [1, 3, 5, 7, 9]

# grep - filter based on === operator
[1, "string", :symbol, 2.5].grep(Numeric)  # => [1, 2.5]

# partition - splits into two arrays (matching/non-matching)
odd, even = numbers.partition { |n| n.odd? }
# odd => [1, 3, 5, 7, 9], even => [2, 4, 6, 8, 10]
        

class MyCollection
  include Enumerable
  
  def initialize(*items)
    @items = items
  end
  
  # Only need to define each
  def each
    @items.each { |item| yield item }
  end
end

collection = MyCollection.new(1, 2, 3, 4)
collection.map { |x| x * 2 }      # => [2, 4, 6, 8]
collection.select { |x| x.even? }  # => [2, 4]
collection.reduce(:+)             # => 10
        

Performance Optimization Techniques:

# Using destructive iterators to avoid creating new arrays
array = [1, 2, 3, 4, 5]
array.map! { |x| x * 2 }  # Modifies array in-place

# Using each_with_object to avoid intermediate arrays
result = (1..1000).each_with_object([]) do |i, arr|
  arr << i * 2 if i.even?
end
# More efficient than: (1..1000).select(&:even?).map { |i| i * 2 }

# Using break for early termination
result = [1, 2, 3, 4, 5].each do |num|
  break num if num > 3
end
# result => 4
        

# Creating an enumerator
enum = Enumerator.new do |yielder|
  yielder << 1
  yielder << 2
  yielder << 3
end

enum.each { |x| puts x }  # Outputs: 1, 2, 3

# Converting iterators to enumerators
chars_enum = "hello".each_char  # Returns an Enumerator
chars_enum.with_index { |c, i| puts "#{i}: #{c}" }
        

def fibonacci
  Fiber.new do
    a, b = 0, 1
    loop do
      Fiber.yield a
      a, b = b, a + b
    end
  end
end

fib = fibonacci
10.times { puts fib.resume }  # First 10 Fibonacci numbers
        

require 'parallel'

# Parallel iteration across multiple CPU cores
Parallel.map([1, 2, 3, 4, 5]) do |num|
  # Computation-heavy operation
  sleep(1)
  num * 2
end
# Completes in ~1 second instead of ~5 seconds
        

Class Definition and Structure:

class Vehicle
  @@count = 0  # Class variable
  
  def initialize(make, model)
    @make = make    # Instance variables
    @model = model
    @@count += 1
  end
  
  def specs  # Instance method
    "#{@make} #{@model}"
  end
  
  def self.count  # Class method
    @@count
  end
end
        

Singleton Classes and Eigenclasses:

car = Vehicle.new("Honda", "Civic")

# Creating a singleton method on just this object
def car.special_feature
  "Custom sound system"
end

# This doesn't affect other Vehicle instances
truck = Vehicle.new("Ford", "F-150")
puts car.special_feature       # => "Custom sound system"
puts truck.respond_to?(:special_feature)  # => false
        

# Class definition is executable context
class Person
  puts "Inside class definition: #{self}"  # Outputs: Inside class definition: Person
  
  SPECIES = "Human"  # Constant defined within class scope
  
  def self.species_info
    "Members of #{self} are #{SPECIES}"
  end
end

puts Person.species_info  # "Members of Person are Human"
        

Instance Variable Implementation Details:

class Product
  def initialize(name)
    @name = name
    # @price doesn't exist yet
  end
  
  def price=(value)
    @price = value  # Creates @price instance variable when first assigned
  end
  
  def details
    # Instance variables that don't exist return nil
    price_info = @price.nil? ? "unpriced" : "$#{@price}"
    "#{@name}: #{price_info}"
  end
end

product = Product.new("Widget")
puts product.details        # "Widget: unpriced"
puts product.instance_variables  # [:@name]

product.price = 19.99
puts product.details        # "Widget: $19.99"
puts product.instance_variables  # [:@name, :@price]

# Access via reflection
puts product.instance_variable_get(:@name)  # "Widget"
product.instance_variable_set(:@name, "Super Widget")
puts product.instance_variable_get(:@name)  # "Super Widget"
        

Method Dispatch and Binding:

class Device
  def initialize(serial)
    @serial = serial
    @status = "off"
  end
  
  def power_on
    @status = "on"
    self  # Return self for method chaining
  end
  
  def info
    "Device ##{@serial} is #{@status}"
  end
  
  # Methods can be defined dynamically
  ["reset", "calibrate", "diagnose"].each do |action|
    define_method(action) do |*args|
      "Performing #{action} with #{args.join(', ')}"
    end
  end
end

# Method binding and dispatch
device = Device.new("ABC123")
puts device.power_on.info  # "Device #ABC123 is on"
puts device.calibrate(3, "high")  # "Performing calibrate with 3, high"

# Method objects
info_method = device.method(:info)
puts info_method.call  # "Device #ABC123 is on"

# UnboundMethod objects
power_method = Device.instance_method(:power_on)
bound_method = power_method.bind(device)
bound_method.call
        

Access Control Implementation:

class BankAccount
  attr_reader :balance  # Creates a getter method
  
  def initialize(owner, initial_deposit)
    @owner = owner
    @balance = initial_deposit
    @account_number = generate_number
  end
  
  # Custom setter with validation
  def balance=(new_amount)
    raise ArgumentError, "Balance cannot be negative" if new_amount < 0
    @balance = new_amount
  end
  
  # Custom getter with formatting
  def owner
    @owner.upcase
  end
  
  private
  
  def generate_number
    # Private method
    "ACCT-#{rand(10000..99999)}"
  end
end

# Using instance_eval to access private variables (metaprogramming technique)
account = BankAccount.new("John Smith", 1000)
puts account.instance_eval { @account_number }  # Directly access private instance variable
        

Detailed Example:

class Vehicle
  attr_accessor :speed
  
  def initialize(speed = 0)
    @speed = speed
  end
  
  def accelerate(amount)
    @speed += amount
  end
  
  def brake(amount)
    @speed -= amount
    @speed = 0 if @speed < 0
  end
end

class Car < Vehicle
  attr_accessor :make, :model
  
  def initialize(make, model, speed = 0)
    super(speed)  # Calls Vehicle#initialize
    @make = make
    @model = model
  end
  
  def honk
    "Beep beep!"
  end
  
  # Override with extension
  def accelerate(amount)
    puts "Pressing gas pedal..."
    super  # Calls Vehicle#accelerate
  end
end

# Method lookup demonstration
tesla = Car.new("Tesla", "Model S")
tesla.accelerate(30)  # Calls Car#accelerate, which calls Vehicle#accelerate
tesla.brake(10)       # Calls Vehicle#brake directly
        

Examining the Inheritance Chain:

# Display class hierarchy
Car.ancestors
# => [Car, Vehicle, Object, Kernel, BasicObject]

# Checking method origin
Car.instance_methods(false)  # Methods defined directly in Car
# => [:make, :model, :make=, :model=, :initialize, :honk, :accelerate]

Vehicle.instance_methods(false)  # Methods defined directly in Vehicle
# => [:speed, :speed=, :initialize, :accelerate, :brake]
        

Class Hierarchy Exploration:

class Base
end

class Derived < Base
end

# Examining the inheritance structure
puts Derived.superclass      # Output: Base
puts Base.superclass         # Output: Object
puts Object.superclass       # Output: BasicObject
puts BasicObject.superclass  # Output: nil

# Viewing the complete ancestor chain
p Derived.ancestors  
# Output: [Derived, Base, Object, Kernel, BasicObject]
        

Method Overriding with Runtime Implications:

class Shape
  def area
    raise NotImplementedError, "#{self.class} must implement area"
  end
  
  def to_s
    "A shape with area: #{area}"
  end
end

class Rectangle < Shape
  def initialize(width, height)
    @width = width
    @height = height
  end
  
  # Override the abstract method
  def area
    @width * @height
  end
end

# Polymorphic behavior
shapes = [Rectangle.new(3, 4)]
shapes.each { |shape| puts shape.to_s }  # Output: "A shape with area: 12"

# Method defined in Shape calls overridden implementation in Rectangle
        

Advanced super Usage Patterns:

class Parent
  def initialize(name, options = {})
    @name = name
    @options = options
  end
  
  def greet(prefix = "Hello")
    "#{prefix}, #{@name}"
  end
  
  def process
    puts "Parent processing"
    yield if block_given?
  end
end

class Child < Parent
  def initialize(name, age, options = {})
    # Pass selected arguments to parent
    super(name, options.merge(child_specific: true))
    @age = age
  end
  
  def greet(prefix = "Hi")
    # Extend parent behavior
    result = super
    "#{result} (#{@age} years old)"
  end
  
  def process
    # Forward block to parent
    super do
      puts "Child-specific processing"
    end
    puts "Child processing complete"
  end
end

child = Child.new("Ruby", 30, { verbose: true })
puts child.greet("Hey")
# Output: "Hey, Ruby (30 years old)"

child.process
# Output:
# Parent processing
# Child-specific processing
# Child processing complete
        

Including Modules and super:

module Loggable
  def log_action(action)
    puts "Logging: #{action}"
  end
  
  def perform(action)
    log_action(action)
    puts "Performing #{action}"
  end
end

class Service
  def perform(action)
    puts "Service performing #{action}"
    yield if block_given?
  end
end

class LoggedService < Service
  include Loggable
  
  def perform(action)
    # Calls Loggable#perform, NOT Service#perform
    # Because Loggable appears earlier in the ancestor chain
    super
    puts "LoggedService completed #{action}"
  end
end

# Method lookup path
p LoggedService.ancestors
# Output: [LoggedService, Loggable, Service, Object, Kernel, BasicObject]

LoggedService.new.perform("sync")
# Output:
# Logging: sync
# Performing sync
# LoggedService completed sync
        

1. Include - Instance Level Mixing:

module Loggable
  def log(message)
    puts "[LOG] #{message}"
  end
end

class Service
  include Loggable
  
  def perform
    log("Service performed")  # Method available at instance level
  end
end

Service.new.log("Direct access")  # Works
# Service.log("Class level")      # Raises NoMethodError
        

2. Extend - Class Level Mixing:

module Findable
  def find_by_name(name)
    all.detect { |item| item.name == name }
  end
end

class Product
  extend Findable
  
  def self.all
    @all ||= []
  end
end

# Product.find_by_name("Widget")  # Method available at class level
# Product.new.find_by_name("Widget") # Raises NoMethodError
        

3. Prepend - Instance Level with Method Precedence:

module Instrumentation
  def save
    start_time = Time.now
    result = super  # Calls the original method
    duration = Time.now - start_time
    puts "Save took #{duration} seconds"
    result
  end
end

class Record
  prepend Instrumentation
  
  def save
    # Original implementation
    puts "Saving record..."
    true
  end
end

Record.new.save
# Output:
# Saving record...
# Save took 0.001 seconds
        

Method Lookup Chain Example:

module M1; def foo; "M1#foo"; end; end
module M2; def foo; "M2#foo"; end; end

class C
  include M1
  prepend M2
  
  def foo
    "C#foo"
  end
end

puts C.ancestors.inspect
# Output: [M2, C, M1, Object, Kernel, BasicObject]
puts C.new.foo
# Output: "M2#foo" (prepended module takes precedence)
        

module Searchable
  module ClassMethods
    def search(query)
      # Class-level search implementation
    end
  end
  
  module InstanceMethods
    def matches?(query)
      # Instance-level matching logic
    end
  end
  
  def self.included(base)
    base.extend(ClassMethods)
    base.include(InstanceMethods)
  end
end

class Article
  include Searchable
  # Now has both search class method and matches? instance method
end
        

class MyClass
  include Enumerable
end

MyClass.included_modules  # => [Enumerable, Kernel]
MyClass.ancestors         # => [MyClass, Enumerable, Object, Kernel, BasicObject]
        

Namespace Implementation:

module PaymentProcessing
  GATEWAY_URL = "https://payment.example.com/api/v2"
  
  class CreditCard
    def process(amount)
      # Implementation
    end
  end
  
  module Validators
    class Luhn
      def self.valid?(number)
        # Implementation
      end
    end
  end
  
  # Nested namespace referencing
  def self.validate_card(number)
    Validators::Luhn.valid?(number)
  end
end

# External reference to nested constants
PaymentProcessing::CreditCard.new
PaymentProcessing::Validators::Luhn.valid?("4111111111111111")
PaymentProcessing::GATEWAY_URL
        

Working with Name Resolution:

module Admin
  class User
    def self.find(id)
      # Admin user lookup implementation
    end
  end
  
  class Dashboard
    # Relative constant reference (same namespace)
    def admin_user
      User.find(1)  
    end
    
    # Absolute path with :: prefix (root namespace)
    def regular_user
      ::User.find(1)
    end
  end
end

# Global namespace
class User
  def self.find(id)
    # Regular user lookup implementation
  end
end
        

Implementation Details:

module Trackable
  def track_event(name)
    puts "Tracking: #{name}"
  end
  
  def self.included(base)
    puts "Trackable included in #{base}"
  end
  
  def self.extended(base)
    puts "Trackable extended in #{base}"
  end
end

# Include: adds instance methods
class Order
  include Trackable
  
  def complete
    track_event("order_completed")
  end
end

# Extend: adds class methods
class Product
  extend Trackable
  
  def self.create
    track_event("product_created")
  end
end

# Demonstrate usage
Order.new.track_event("test")  # Works
# Order.track_event("test")    # NoMethodError

# Product.track_event("test")  # Works
# Product.new.track_event("test") # NoMethodError
        

1. Dual-purpose Modules (both class and instance methods):

module Authentication
  # Instance methods
  def authenticate(password)
    # Implementation
  end
  
  # Hook invoked when module is included
  def self.included(base)
    base.extend(ClassMethods)
  end
  
  # Submodule for class methods
  module ClassMethods
    def authenticate_with_token(token)
      # Implementation
    end
  end
end

class User
  include Authentication
  # Now User has instance method #authenticate
  # and class method .authenticate_with_token
end
        

2. Using prepend for Method Overriding:

module Cacheable
  def find_by_id(id)
    puts "Checking cache first"
    cached_result = read_from_cache(id)
    return cached_result if cached_result
    
    # Fall back to original implementation
    result = super
    write_to_cache(id, result)
    result
  end
  
  private
  
  def read_from_cache(id)
    # Implementation
  end
  
  def write_to_cache(id, data)
    # Implementation
  end
end

class Repository
  prepend Cacheable
  
  def find_by_id(id)
    puts "Finding record #{id} in database"
    # Database lookup implementation
  end
end

# When called, the Cacheable#find_by_id executes first
Repository.new.find_by_id(42)
# Output:
# Checking cache first
# Finding record 42 in database
        

class Service
  include Comparable
  extend Enumerable
end

# Examining inheritance structure
p Service.included_modules         # [Comparable, Kernel]
p Service.singleton_class.included_modules  # [Enumerable, ...]

# Adding modules dynamically
module ExtraFeatures; end
Service.include(ExtraFeatures) if ENV["ENABLE_EXTRAS"]

# Testing for module inclusion
p Service.include?(Comparable)  # true
p Service.singleton_class.include?(Enumerable)  # true
        

Block Implementation Details:

def execute_block
  yield if block_given?
end

execute_block { puts "Block executed" }

# Block parameters and variables
x = 10
[1, 2, 3].each do |number|
  puts number + x  # Accesses x from outer scope
end

# Behind the scenes, the Ruby VM converts blocks to a special internal representation

Proc Internal Behavior:

# Creating Procs - multiple ways
proc1 = Proc.new { |x| x * 2 }
proc2 = proc { |x| x * 2 }  # Kernel#proc is a shorthand

# Arity checking is relaxed
p = Proc.new { |a, b| [a, b] }
p.call(1)      # => [1, nil]
p.call(1, 2, 3) # => [1, 2] (extra arguments discarded)

# Return behavior
def proc_return_test
  p = Proc.new { return "Returning from method!" }
  p.call
  puts "This line never executes"
end

proc_return_test  # Returns from the method when Proc executes

Lambda Internal Behavior:

# Creating lambdas
lambda1 = lambda { |x| x * 2 }
lambda2 = ->(x) { x * 2 }  # Stabby lambda syntax

# Strict arity checking
l = ->(a, b) { [a, b] }
# l.call(1)     # ArgumentError: wrong number of arguments (given 1, expected 2)
# l.call(1,2,3) # ArgumentError: wrong number of arguments (given 3, expected 2)

# Return behavior
def lambda_return_test
  l = lambda { return "Returning from lambda only!" }
  result = l.call
  puts "This line WILL execute"
  result
end

lambda_return_test  # The lambda's return only exits the lambda, not the method

Block Implementation Details:

# Method with yield
def with_logging
  puts "Starting operation"
  result = yield if block_given?
  puts "Operation complete"
  result
end

# Method that explicitly captures a block as Proc
def with_explicit_block(&block)
  puts "Block object: #{block.class}"
  block.call if block
end

# Block local variables vs. closure scope
outer = "visible"
[1, 2, 3].each do |num; inner|  # inner is a block-local variable
  inner = "not visible outside"
  puts "#{num}: Can access outer: #{outer}"
end
# puts inner  # NameError: undefined local variable

Proc Technical Details:

# Return semantics - Procs return from the method they're defined in
def proc_return_demo
  puts "Method started"
  my_proc = Proc.new { return "Early return from proc" }
  my_proc.call
  puts "This never executes"
  return "Normal method return"
end

# Parameter handling in Procs
param_proc = Proc.new { |a, b, c| puts "a:#{a}, b:#{b}, c:#{c}" }
param_proc.call(1)            # a:1, b:nil, c:nil
param_proc.call(1, 2, 3, 4)   # a:1, b:2, c:3 (4 is ignored)

# Converting blocks to Procs
def make_counter
  count = 0
  Proc.new { count += 1 }
end

counter = make_counter
puts counter.call  # 1
puts counter.call  # 2 - maintains state between calls

Lambda Technical Details:

# Return semantics - lambda returns control to calling context
def lambda_return_demo
  puts "Method started"
  my_lambda = -> { return "Return from lambda" }
  result = my_lambda.call
  puts "Still executing, lambda returned: #{result}"
  return "Normal method return"
end

# Parameter handling with advanced syntax
required_lambda = ->(a, b = 1, *rest, required_keyword:, optional_keyword: nil) {
  puts "a: #{a}, b: #{b}, rest: #{rest}, " +
       "required_keyword: #{required_keyword}, optional_keyword: #{optional_keyword}"
}

# Currying and partial application
multiply = ->(x, y) { x * y }
double = multiply.curry[2]
puts double.call(5)  # 10

# Method objects vs lambdas
obj = Object.new
def obj.my_method(x); x * 2; end
method_object = obj.method(:my_method)
# method_object is similar to a lambda but bound to the object

# ActiveRecord query builder pattern
User.where(active: true).order(created_at: :desc).limit(5).each do |user|
  # Process users
end

# Resource management pattern
Database.transaction do |tx|
  tx.execute("UPDATE users SET status = 'active'")
  tx.execute("INSERT INTO audit_logs (message) VALUES ('Activated users')")
end

# Configuration blocks
ApplicationConfig.setup do |config|
  config.timeout = 30
  config.retry_count = 3
  config.logger = Logger.new($stdout)
end

# Event system with callbacks
class EventEmitter
  def initialize
    @callbacks = {}
  end
  
  def on(event, &callback)
    @callbacks[event] ||= []
    @callbacks[event] << callback
  end
  
  def emit(event, *args)
    return unless @callbacks[event]
    @callbacks[event].each { |callback| callback.call(*args) }
  end
end

# Memoization pattern
def memoize
  cache = {}
  Proc.new do |*args|
    cache[args] ||= yield(*args)
  end
end

expensive_calculation = memoize { |n| sleep(1); n * n }

# Function composition
compose = ->(*fns) {
  ->(x) { fns.reverse.reduce(x) { |acc, fn| fn.call(acc) } }
}

add_one = ->(x) { x + 1 }
double = ->(x) { x * 2 }
composed = compose.call(double, add_one)
puts composed.call(3)  # (3+1)*2 = 8

# HTTP middleware pattern
class Middleware
  def initialize(app)
    @app = app
  end
  
  def use(middleware)
    @app = middleware.new(@app)
    self
  end
  
  def call(env)
    @app.call(env)
  end
end

# Validation with lambdas
validators = {
  presence: ->(value) { !value.nil? && !value.empty? },
  numeric: ->(value) { value.to_s.match?(/^\d+$/) },
  email: ->(value) { value.to_s.match?(/\A[\w+\-.]+@[a-z\d\-]+(\.[a-z\d\-]+)*\.[a-z]+\z/i) }
}

Full Exception Structure:

begin
  # Code that might raise exceptions
rescue SpecificError => error_variable
  # Handle specific error
rescue AnotherError, YetAnotherError => error_variable
  # Handle multiple error types
rescue => error_variable  # Defaults to StandardError
  # Handle any StandardError
else
  # Executes only if no exceptions were raised
ensure
  # Always executes, regardless of exceptions
end
        

Custom Exception Classes:

# Creating a custom exception hierarchy
class ApplicationError < StandardError; end
class DatabaseError < ApplicationError
  attr_reader :query

  def initialize(message = "A database error occurred", query = nil)
    @query = query
    super(message)
  end
end

# Usage
begin
  # Database operation
  raise DatabaseError.new("Connection failed", "SELECT * FROM users")
rescue DatabaseError => e
  puts "Error: #{e.message}, Query: #{e.query}"
end
        

def process_data
  begin
    # Process data
  rescue StandardError => e
    logger.error("Error during processing: #{e.message}")
    raise # Re-raises the current exception
  end
end

# Or with transformation
begin
  # Some operation
rescue ArgumentError => e
  # Wrap in a different exception type with context
  raise CustomError.new("Invalid input: #{e.message}").tap { |ex| ex.set_backtrace(e.backtrace) }
end
        

begin
  # Protected code block that might raise exceptions
rescue ExceptionType1 => e
  # Handler for ExceptionType1
rescue ExceptionType2, ExceptionType3 => e
  # Handler for multiple exception types
rescue => e  # Shorthand for `rescue StandardError => e`
  # Fallback handler for any StandardError
else
  # Executes only if no exceptions were raised in the begin block
ensure
  # Always executes after begin, rescue and else clauses
  # Runs regardless of whether an exception occurred
end
        

begin
  # Code that might raise exceptions
rescue => e
  # Standard exception introspection methods
  puts e.message       # String description of the error
  puts e.class         # The exception class
  puts e.backtrace     # Array of strings showing the call stack
  puts e.cause         # The exception that caused this one (Ruby 2.1+)
  
  # Capturing the complete context
  e.instance_variables.each do |var|
    puts "#{var}: #{e.instance_variable_get(var)}"
  end
end
        

# Method definitions have implicit begin
def process_file(path)
  # Method body is implicitly wrapped in a begin block
rescue Errno::ENOENT
  # Handle file not found
end

# Class/module definitions, loops, etc. also have implicit begin
class MyClass
  # Class body has implicit begin
rescue => e
  # Handle exceptions during class definition
end
        

# Basic raise forms
raise                     # Raises RuntimeError with no message
raise "Error message"     # Raises RuntimeError with message
raise ArgumentError       # Raises an ArgumentError with no message
raise ArgumentError.new("Invalid argument") # Raises with message

# Creating and raising in one step
raise ArgumentError, "Invalid argument", caller # With custom backtrace
raise ArgumentError, "Invalid argument", caller[2..-1] # Partial backtrace
        

# Base application exception
class ApplicationError < StandardError; end

# Domain-specific exception categories
class ValidationError < ApplicationError; end
class AuthorizationError < ApplicationError; end
class ResourceError < ApplicationError; end

# Specific exception types
class ResourceNotFoundError < ResourceError
  attr_reader :resource_type, :identifier

  def initialize(resource_type, identifier, message = nil)
    @resource_type = resource_type
    @identifier = identifier
    super(message || "#{resource_type} not found with identifier: #{identifier}")
  end
end

# Usage
begin
  user = User.find(id) || raise(ResourceNotFoundError.new("User", id))
rescue ResourceNotFoundError => e
  logger.error("Resource access failure: #{e.message}")
  redirect_to_error_page(resource_type: e.resource_type)
end
        

# Converting third-party exceptions to application-specific ones
def fetch_data
  begin
    external_api.request(params)
  rescue ExternalAPI::ConnectionError => e
    raise NetworkError.new("API connection failed").tap do |error|
      error.original_exception = e  # Store original for debugging
      error.set_backtrace(e.backtrace)  # Preserve original backtrace
    end
  end
end
        

def fetch_with_retry(max_attempts = 3)
  attempts = 0
  begin
    attempts += 1
    response = api.fetch
  rescue ApiError => e
    if attempts < max_attempts
      sleep(attempts * 2)  # Exponential backoff
      retry
    else
      raise
    end
  end
end
        

class CircuitBreaker
  def initialize(threshold = 5, timeout = 60)
    @failure_count = 0
    @threshold = threshold
    @timeout = timeout
    @state = :closed  # :closed, :open, :half_open
    @last_failure_time = nil
  end

  def execute
    check_state
    
    begin
      result = yield
      success
      result
    rescue => e
      failure(e)
    end
  end

  private
  
  def check_state
    case @state
    when :open
      if Time.now - @last_failure_time > @timeout
        @state = :half_open
      else
        raise CircuitOpenError, "Circuit breaker is open"
      end
    when :half_open, :closed
      # Allow execution
    end
  end

  def success
    @failure_count = 0
    @state = :closed if @state == :half_open
  end

  def failure(exception)
    @failure_count += 1
    @last_failure_time = Time.now
    
    if @state == :half_open || @failure_count >= @threshold
      @state = :open
    end
    
    raise exception
  end
end

# Usage
breaker = CircuitBreaker.new
breaker.execute { api.fetch_data }
        

Bundler's Dependency Resolution Process:

1. Parses the Gemfile to extract gem requirements
2. Builds a dependency graph of all gems and their dependencies
3. Uses a backtracking algorithm to find a set of gem versions that satisfy all constraints
4. Resolves the dependency graph to a concrete set of gems and versions
5. Documents the resolved dependencies in Gemfile.lock
6. Installs the gems in the specified environments (development, test, production)

Gemfile with Advanced Features:

source 'https://rubygems.org'
ruby '3.1.2'

# Core gems
gem 'rails', '~> 7.0.4'
gem 'pg', '~> 1.4.3'
gem 'puma', '~> 5.6.5'

# Environment-specific gems
group :development, :test do
  gem 'rspec-rails', '~> 6.0.0'
  gem 'factory_bot_rails', '~> 6.2.0'
  gem 'debug', platforms: [:mri, :mingw, :x64_mingw]
end

group :production do
  gem 'rack-timeout', '~> 0.6.3'
  gem 'newrelic_rpm', '~> 8.12.0'
end

# Platform-specific gems
platforms :ruby do
  gem 'unicorn'
end

# Git source example
gem 'rails_admin', git: 'https://github.com/rails/rails_admin.git', branch: 'main'

# Path source example (for local development)
gem 'my_custom_gem', path: '../my_custom_gem'

Bundler Runtime Implementation:

# How Bundler is typically initialized in a Rails app
require 'bundler/setup'      # Set up load paths for all gems in Gemfile
Bundler.require(:default)      # Require all default gems
Bundler.require(Rails.env)     # Require environment-specific gems

Gemfile Directive Types:

# Source directives
source 'https://rubygems.org'                     # Primary gem source
source 'https://enterprise.gem-server.com' do     # Scoped source
  gem 'private-enterprise-gem'
end

# Ruby version constraint
ruby '3.1.2', patchlevel: '224'                 # Specific Ruby version requirement

# Basic gem specifications with version constraints
gem 'rails', '~> 7.0.4'                         # Pessimistic version constraint (~>)
gem 'pg', '>= 1.4.0', '< 2.0'                 # Multiple version constraints
gem 'redis', '4.8.0'                            # Exact version

# Gem with options
gem 'nokogiri', '~> 1.13.9',
    require: false,                               # Don't auto-require
    platforms: [:ruby, :mingw, :x64_mingw]        # Platform-specific

# Alternative sources
gem 'rails_admin', 
    git: 'https://github.com/rails/rails_admin.git',  # Git source
    branch: 'main',                                   # Git branch
    ref: 'a204e96'                                    # Git reference

gem 'local_gem', path: '../local_gem'              # Local path source

# Environment-specific gems
group :development do
  gem 'web-console'
  gem 'rack-mini-profiler'
end

group :test do
  gem 'capybara'
  gem 'selenium-webdriver'
end

# Multiple environments
group :development, :test do
  gem 'rspec-rails'
  gem 'factory_bot_rails'
  gem 'debug'
end

# Conditional gems
install_if -> { RUBY_PLATFORM =~ /darwin/ } do     # Install only on macOS
  gem 'terminal-notifier'
end

# Platform-specific gems
platforms :jruby do
  gem 'activerecord-jdbcpostgresql-adapter'
end

Gemfile.lock Structure (Excerpt):

GEM
  remote: https://rubygems.org/
  specs:
    actioncable (7.0.4)
      actionpack (= 7.0.4)
      activesupport (= 7.0.4)
      nio4r (~> 2.0)
      websocket-driver (>= 0.6.1)
    actionmailbox (7.0.4)
      actionpack (= 7.0.4)
      activejob (= 7.0.4)
      activerecord (= 7.0.4)
      activestorage (= 7.0.4)
      activesupport (= 7.0.4)
      mail (>= 2.7.1)
      net-imap
      net-pop
      net-smtp

GIT
  remote: https://github.com/rails/rails_admin.git
  revision: a204e96c221228fcd537e2a59141909796d384b5
  branch: main
  specs:
    rails_admin (3.1.0)
      activemodel-serializers-xml (>= 1.0)
      kaminari (>= 0.14, < 2.0)
      nested_form (~> 0.3)
      rails (>= 6.0, < 8)
      turbo-rails (~> 1.0)

PLATFORMS
  arm64-darwin-21
  x86_64-linux

DEPENDENCIES
  bootsnap
  debug
  jbuilder
  puma (~> 5.0)
  rails (~> 7.0.4)
  rails_admin!
  rspec-rails
  sqlite3 (~> 1.4)
  turbo-rails

RUBY VERSION
   ruby 3.1.2p224

BUNDLED WITH
   2.3.22

Core RubyGems Commands:

• gem install [gemname] -v [version] - Installs a specific gem version
• gem uninstall [gemname] --all - Removes all versions of a gem
• gem pristine [gemname] - Restores gem to original condition
• gem cleanup - Removes old versions of gems
• gem query --remote --name-matches [pattern] - Searches for gems matching pattern
• gem server - Starts a local RDoc server for installed gems
• gem build [gemspec] - Builds a gem from a gemspec
• gem push [gemfile] - Publishes a gem to RubyGems.org
• gem yank [gemname] -v [version] - Removes a published gem version

Advanced Bundler Commands:

• bundle install --deployment - Installs for production with strict Gemfile.lock checking
• bundle install --jobs=4 - Parallel gem installation
• bundle update --conservative [gemname] - Updates a gem with minimal changes
• bundle check - Verifies if dependencies are satisfied
• bundle lock --update - Updates lockfile without installing
• bundle outdated - Shows gems with newer versions available
• bundle viz - Generates a visual dependency graph
• bundle config set --local path 'vendor/bundle' - Sets bundle install path
• bundle package - Packages gems into vendor/cache
• bundle exec --keep-file-descriptors [command] - Runs with gem environment with preserved file handles
• bundle binstubs [gemname] - Creates executable stubs for gem commands
• bundle open [gemname] - Opens gem source in editor