RubyDev - The Home for Ruby Developers

Method Aliasing & Method Missing

Ruby's method aliasing system allows you to create alternative names for methods, while method_missing provides a powerful way to handle undefined method calls dynamically. These features enable flexible and expressive Ruby programming.

Method Aliasing

Method Aliasing: Create alternative names for existing methods using alias_method or alias. Useful for backward compatibility, API design, and method enhancement.

Basic Method Aliasing

# Basic method aliasing
class
String
  alias_method :old_reverse, :reverse
  
  def reverse
    puts "Reversing string..."
    old_reverse
  end
end

text = "hello"
puts text.reverse
# "Reversing string..." then "olleh"
puts text.old_reverse
# "olleh" (original method)

Alias vs Alias Method

# Using alias (syntax sugar)
class
Calculator
  def add(a, b)
    a + b
  end
  
  alias plus add # Creates alias 'plus' for 'add'
end

calc = Calculator.new
puts calc.add(5, 3)
# 8
puts calc.plus(5, 3)
# 8

# Using alias_method (more flexible)
class
Calculator
  alias_method :subtract, :minus # Can use symbols or strings
  alias_method "multiply", "times"
end

Method Missing

Method Missing: Ruby calls method_missing when a method is not found. Override it to create dynamic method handling, DSLs, and flexible APIs.

Basic Method Missing

# Basic method_missing implementation
class
DynamicCalculator
  def initialize
    @operations = {}
  end
  
  def method_missing(method_name, *args, &block)
    if method_name.to_s.start_with?("calculate_")
      operation = method_name.to_s.gsub("calculate_", "")
      puts "Performing \#{operation} with \#{args.join(', ')}"
      return 42 # Placeholder result
    end
    
    super # Call parent method_missing
  end
end

calc = DynamicCalculator.new
puts calc.calculate_add(5, 3)
# "Performing add with 5, 3" then 42
puts calc.calculate_multiply(4, 7)
# "Performing multiply with 4, 7" then 42
# calc.unknown_method
# NoMethodError

Advanced Method Missing

# Dynamic attribute accessor
class
DynamicHash
  def initialize
    @data = {}
  end
  
  def method_missing(method_name, *args)
    method_str = method_name.to_s
    
    if method_str.end_with?("=")
      # Setter method (name=)
      key = method_str.chomp("=").to_sym
      @data[key] = args.first
    else
      # Getter method
      @data[method_name]
    end
  end
end

hash = DynamicHash.new
hash.name = "Alice"
hash.age = 25
puts
hash.name
# "Alice"
puts
hash.age
# 25

Respond To Method

Respond To Method: Override respond_to? to make your dynamic methods work properly with introspection and duck typing.

Respond To Method Example

# Complete dynamic method implementation
class
SmartCalculator
  def method_missing(method_name, *args)
    if method_name.to_s.start_with?("calculate_")
      operation = method_name.to_s.gsub("calculate_", "")
      case operation
      when "add" then args.reduce(:+)
      when "multiply" then args.reduce(:*)
      else super
      end
    else
      super
    end
  end
  
  def respond_to_missing?(method_name, include_private = false)
    method_name.to_s.start_with?("calculate_") || super
  end
end

calc = SmartCalculator.new
puts calc.respond_to?(:calculate_add)
# true
puts calc.respond_to?(:calculate_multiply)
# true
puts calc.respond_to?(:unknown_method)
# false

puts calc.calculate_add(1, 2, 3)
# 6
puts calc.calculate_multiply(2, 3, 4)
# 24

Interactive Practice: Method Aliasing & Method Missing

Practice Time: Try these method aliasing and method_missing examples. Understanding these patterns will make you a more effective Ruby programmer.

Interactive Code Runner

Ruby Code Editor

# Try these comprehensive method aliasing examples!

# 1. Basic method aliasing
class String
  alias_method :old_reverse, :reverse
  
  def reverse
    puts "Reversing string..."
    old_reverse
  end
end

puts "hello".reverse
puts "world".old_reverse

# 2. Dynamic method aliasing
class Calculator
  def add(a, b)
    a + b
  end
  
  def multiply(a, b)
    a * b
  end
  
  # Create aliases dynamically
  alias_method :plus, :add
  alias_method :times, :multiply
end

calc = Calculator.new
puts calc.plus(5, 3)      # 8
puts calc.times(4, 6)     # 24

# 3. Method redefinition
class User
  def initialize(name)
    @name = name
    @login_count = 0
  end
  
  def login
    @login_count += 1
    puts "#{@name} logged in (count: #{@login_count})"
  end
  
  # Redefine login to add logging
  alias_method :original_login, :login
  
  def login
    puts "[LOG] Login attempt for #{@name}"
    original_login
    puts "[LOG] Login successful"
  end
end

user = User.new("Alice")
user.login
user.login

# 4. method_missing for dynamic methods
class DynamicAPI
  def initialize
    @data = {}
  end
  
  def method_missing(method_name, *args, &block)
    if method_name.to_s.end_with?('=')
      # Setter method
      key = method_name.to_s.chomp('=').to_sym
      @data[key] = args.first
      puts "Set #{key} = #{args.first}"
    elsif @data.key?(method_name)
      # Getter method
      puts "Get #{method_name} = #{@data[method_name]}"
      @data[method_name]
    else
      super
    end
  end
  
  def respond_to_missing?(method_name, include_private = false)
    method_name.to_s.end_with?('=') || @data.key?(method_name) || super
  end
end

api = DynamicAPI.new
api.name = "Alice"
api.age = 25
api.name
api.age

# 5. method_missing with delegation
class Logger
  def initialize
    @messages = []
  end
  
  def log(level, message)
    @messages << "[#{level.upcase}] #{message}"
  end
  
  def method_missing(method_name, *args)
    if [:info, :warn, :error, :debug].include?(method_name)
      log(method_name, args.first)
    else
      super
    end
  end
  
  def respond_to_missing?(method_name, include_private = false)
    [:info, :warn, :error, :debug].include?(method_name) || super
  end
  
  def messages
    @messages
  end
end

logger = Logger.new
logger.info("Application started")
logger.warn("Low memory warning")
logger.error("Database connection failed")
puts logger.messages

# 6. Method chaining with method_missing
class Chainable
  def initialize
    @operations = []
  end
  
  def method_missing(method_name, *args)
    @operations << { method: method_name, args: args }
    self
  end
  
  def respond_to_missing?(method_name, include_private = false)
    true  # Accept any method for chaining
  end
  
  def execute
    puts "Executing operations: #{@operations.map { |op| "#{op[:method]}(#{op[:args].join(', ')})" }.join(' -> ')}"
    @operations.clear
  end
end

chain = Chainable.new
chain.process_data.filter_results.sort_by_name.execute

# Add your own method aliasing experiments below!

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

Best Practices & Common Patterns

✅ Best Practices

Always override respond_to_missing? with method_missing
Use alias_method for dynamic aliasing
Call super in method_missing for unknown methods
Document dynamic method patterns clearly
Use method_missing sparingly - prefer explicit methods
Consider performance implications of dynamic methods

❌ Common Pitfalls

Forgetting to override respond_to_missing?
Not calling super in method_missing
Overusing method_missing for simple cases
Creating infinite loops in method_missing
Not handling edge cases in dynamic methods
Making methods too magical and hard to debug

Method Aliasing & Method Missing Mastery Summary

You've Mastered Method Aliasing & Method Missing!

Method Aliasing

Create alternative names for existing methods

Method Missing

Handle undefined method calls dynamically

Respond To

Make dynamic methods work with introspection

Method aliasing and method_missing are powerful Ruby features that enable dynamic programming patterns. Use them judiciously to create flexible, expressive APIs while maintaining code clarity and performance.

Method Aliasing & Method Missing

Method Aliasing & Method Missing

Method Aliasing

Basic Method Aliasing

Alias vs Alias Method

Method Missing

Basic Method Missing

Advanced Method Missing

Respond To Method

Respond To Method Example

Interactive Practice: Method Aliasing & Method Missing

Interactive Code Runner

Ruby Code Editor

Best Practices & Common Patterns

✅ Best Practices

❌ Common Pitfalls

Method Aliasing & Method Missing Mastery Summary

You've Mastered Method Aliasing & Method Missing!

Method Aliasing

Method Missing

Respond To

Quick Navigation

Related Topics

Video Tutorial

Ruby Language

Rails Framework

Production Ready

Method Aliasing & Method Missing

Method Aliasing & Method Missing

Method Aliasing

Basic Method Aliasing

Alias vs Alias Method

Method Missing

Basic Method Missing

Advanced Method Missing

Respond To Method

Respond To Method Example

Interactive Practice: Method Aliasing & Method Missing

Interactive Code Runner

Ruby Code Editor

Best Practices & Common Patterns

✅ Best Practices

❌ Common Pitfalls

Method Aliasing & Method Missing Mastery Summary

You've Mastered Method Aliasing & Method Missing!

Method Aliasing

Method Missing

Respond To

Quick Navigation

Related Topics

Video Tutorial