RubyDev - The Home for Ruby Developers

Ruby Exception Hierarchy Mastery

Understanding Ruby's exception hierarchy is crucial for effective error handling. Learn about StandardError, RuntimeError, and how to create custom exception classes for better error management.

Exception Hierarchy Overview

Exception Hierarchy: Ruby's exception system is organized in a hierarchy where more specific exceptions inherit from more general ones, allowing for flexible error handling.

Ruby Exception Hierarchy Tree

# Ruby Exception Hierarchy
Exception
├── SystemExit
├── SystemStackError
├── NoMemoryError
├── SecurityError
├── ScriptError
│   ├── LoadError
│   ├── NotImplementedError
│   └── SyntaxError
├── StandardError
│   ├── ArgumentError
│   ├── IOError
│   ├── RuntimeError
│   ├── NameError
│   │   └── NoMethodError
│   ├── IndexError
│   │   └── StopIteration
│   ├── TypeError
│   ├── ZeroDivisionError
│   └── SystemCallError
└── Interrupt

Key Exception Types

# Common exception types and their uses
begin
  # RuntimeError - default for raise
  raise "Something went wrong"
rescue
RuntimeError => e
  puts "Runtime error: \#{e.message}"
end

begin
  # ArgumentError - invalid arguments
raiseArgumentError
, "Invalid argument"
rescue
ArgumentError => e
  puts "Argument error: \#{e.message}"
end

begin
  # TypeError - wrong object type
  1 + "string"
rescue
TypeError => e
  puts "Type error: \#{e.message}"
end

StandardError vs Exception

Important Distinction: Always rescue StandardError, not Exception. Exception includes system-level errors that should not be caught in normal application code.

Correct Exception Handling

# ✅ CORRECT: Rescue StandardError
begin
  # Your application code
  10 / 0
rescue
StandardError => e
  puts "Application error: \#{e.message}"
end

# ❌ WRONG: Don't rescue Exception
begin
  # Your application code
  10 / 0
rescue
Exception => e
  puts "This catches system errors too!"
end

Why StandardError?

# System errors that should NOT be caught:
puts "SystemExit: \#{SystemExit < Exception}"
# true
puts "NoMemoryError: \#{NoMemoryError < Exception}"
# true
puts "SystemStackError: \#{SystemStackError < Exception}"
# true

# Application errors that SHOULD be caught:
puts "RuntimeError: \#{RuntimeError < StandardError}"
# true
puts "ArgumentError: \#{ArgumentError < StandardError}"
# true
puts "ZeroDivisionError: \#{ZeroDivisionError < StandardError}"
# true

Custom Exception Classes

Custom Exceptions: Create domain-specific exception classes that inherit from StandardError for better error handling and debugging.

Basic Custom Exception

# Basic custom exception class
class
ValidationError
 < StandardError
  def initialize(message = "Validation failed")
    super(message)
  end
end

def
validate_email
(email)
          raiseValidationError
, "Invalid email format"unless email.include?("@")
  puts "Email is valid: \#{email}"
end

Advanced Custom Exception

# Advanced custom exception with context
class
APIError
 < StandardError
  attr_reader :status_code, :response_body
  
  def initialize(message, status_code = 500, response_body = nil)
    super(message)
    @status_code = status_code
    @response_body = response_body
  end
  
  def to_s
    "\#{super} (Status: \#{@status_code})"
  end
end

def
make_api_request
(url)
            # Simulate API call
raiseAPIError
.new("Server error", 500, "Internal server error")
end

Interactive Practice: Exception Hierarchy

Practice Time: Try these exception hierarchy examples. Understanding these patterns will make you a more effective Ruby programmer.

Interactive Code Runner

Ruby Code Editor

# Try these comprehensive exception hierarchy examples!

# 1. Custom exception classes
class ValidationError < StandardError
  attr_reader :field, :value
  
  def initialize(message, field = nil, value = nil)
    super(message)
    @field = field
    @value = value
  end
  
  def to_s
    if @field && @value
      "#{super} (Field: #{@field}, Value: #{@value})"
    else
      super
    end
  end
end

class APIError < StandardError
  attr_reader :status_code, :endpoint
  
  def initialize(message, status_code = 500, endpoint = nil)
    super(message)
    @status_code = status_code
    @endpoint = endpoint
  end
  
  def to_s
    "#{super} (Status: #{@status_code}, Endpoint: #{@endpoint})"
  end
end

# 2. Exception hierarchy demonstration
def demonstrate_hierarchy
  puts "=== Exception Hierarchy Demo ==="
  
  # StandardError hierarchy
  puts "RuntimeError < StandardError: #{RuntimeError < StandardError}"
  puts "ArgumentError < StandardError: #{ArgumentError < StandardError}"
  puts "ZeroDivisionError < StandardError: #{ZeroDivisionError < StandardError}"
  
  # Exception hierarchy
  puts "StandardError < Exception: #{StandardError < Exception}"
  puts "SystemExit < Exception: #{SystemExit < Exception}"
  puts "NoMemoryError < Exception: #{NoMemoryError < Exception}"
  
  # Custom exceptions
  puts "ValidationError < StandardError: #{ValidationError < StandardError}"
  puts "APIError < StandardError: #{APIError < StandardError}"
end

# 3. Proper exception handling
def validate_user_data(name, email, age)
  errors = []
  
  begin
    raise ValidationError.new("Name cannot be empty", :name, name) if name.nil? || name.strip.empty?
    raise ValidationError.new("Email must contain @", :email, email) if email.nil? || !email.include?('@')
    raise ValidationError.new("Age must be positive", :age, age) if age.nil? || age <= 0
    
    puts "User validation passed: #{name}, #{email}, #{age}"
    true
    
  rescue ValidationError => e
    puts "Validation failed: #{e}"
    false
  end
end

# 4. API error simulation
def simulate_api_call(endpoint)
  begin
    # Simulate different API responses
    case endpoint
    when "/users"
      raise APIError.new("User service unavailable", 503, endpoint)
    when "/orders"
      raise APIError.new("Invalid order data", 400, endpoint)
    when "/products"
      puts "API call successful: #{endpoint}"
      "Product data"
    else
      raise APIError.new("Unknown endpoint", 404, endpoint)
    end
    
  rescue APIError => e
    puts "API Error: #{e}"
    nil
  end
end

# 5. Exception handling with inheritance
def handle_multiple_exceptions
  begin
    # This will raise a ZeroDivisionError
    10 / 0
    
  rescue ZeroDivisionError => e
    puts "Caught ZeroDivisionError: #{e.message}"
  rescue StandardError => e
    puts "Caught StandardError: #{e.message}"
  rescue Exception => e
    puts "Caught Exception: #{e.message}"
  end
end

# Run the examples
puts "=== Exception Hierarchy Examples ==="
demonstrate_hierarchy

puts "\n=== User Validation Examples ==="
validate_user_data("Alice", "alice@example.com", 25)
validate_user_data("", "invalid-email", -5)

puts "\n=== API Call Examples ==="
simulate_api_call("/users")
simulate_api_call("/orders")
simulate_api_call("/products")
simulate_api_call("/unknown")

puts "\n=== Exception Handling Demo ==="
handle_multiple_exceptions

# Add your own exception hierarchy experiments below!

Output will appear here when you run the code...

Best Practices & Common Patterns

✅ Best Practices

Always inherit from StandardError, not Exception
Use specific exception types for different errors
Provide meaningful error messages
Include context information in custom exceptions
Use exception hierarchy for error classification
Document custom exception behavior

❌ Common Pitfalls

Inheriting from Exception instead of StandardError
Creating too many custom exception classes
Not providing enough context in error messages
Using generic exception types everywhere
Not following naming conventions
Overcomplicating exception hierarchies

Exception Hierarchy Mastery Summary

You've Mastered Ruby Exception Hierarchy!

Exception Hierarchy

StandardError vs Exception distinction

Custom Exceptions

Domain-specific error classes

Error Classification

Organized error handling

Understanding Ruby's exception hierarchy is essential for effective error handling. Use StandardError for application errors and create custom exceptions for domain-specific error conditions.

Exception-hierarchy

Ruby Exception Hierarchy Mastery

Exception Hierarchy Overview

Ruby Exception Hierarchy Tree

Key Exception Types

StandardError vs Exception

Correct Exception Handling

Why StandardError?

Custom Exception Classes

Basic Custom Exception

Advanced Custom Exception

Interactive Practice: Exception Hierarchy

Interactive Code Runner

Ruby Code Editor

Best Practices & Common Patterns

✅ Best Practices

❌ Common Pitfalls

Exception Hierarchy Mastery Summary

You've Mastered Ruby Exception Hierarchy!

Exception Hierarchy

Custom Exceptions

Error Classification

Quick Navigation

Related Topics

Video Tutorial

Ruby Language

Rails Framework

Production Ready

Exception-hierarchy

Ruby Exception Hierarchy Mastery

Exception Hierarchy Overview

Ruby Exception Hierarchy Tree

Key Exception Types

StandardError vs Exception

Correct Exception Handling

Why StandardError?

Custom Exception Classes

Basic Custom Exception

Advanced Custom Exception

Interactive Practice: Exception Hierarchy

Interactive Code Runner

Ruby Code Editor

Best Practices & Common Patterns

✅ Best Practices

❌ Common Pitfalls

Exception Hierarchy Mastery Summary

You've Mastered Ruby Exception Hierarchy!

Exception Hierarchy

Custom Exceptions

Error Classification

Quick Navigation

Related Topics

Video Tutorial