Mastering call() and send() in Ruby

Table of Contents

1. What is call() in Ruby?
2. What is send() in Ruby?
3. Practical Applications of call() and send()
4. Conclusion
5. FAQ

What is call() in Ruby?

The call() method, also known as the “call method” or “callable method,” allows you to invoke a method on an object using the method call operator (). This transforms objects into callable entities, similar to functions or procedures. Any class can define a call() method, making its instances callable.

class Adder
  def initialize(x)
    @x = x
  end

  def call(y)
    @x + y
  end
end

adder = Adder.new(5)
result = adder.call(3)  # result will be 8
result = adder.(3)      # Equivalent using the method call operator
puts result             # Output: 8

call() is invaluable for creating custom functions or code blocks that can be passed and executed later. It’s a cornerstone of Ruby’s functional programming capabilities.

What is send() in Ruby?

The send() method dynamically invokes a method on an object, accepting the method’s name as a string or symbol. This enables runtime manipulation of objects and their methods.

class Greeter
  def hello(name)
    "Hello, #{name}!"
  end

  def goodbye(name)
    "Goodbye, #{name}!"
  end
end

greeter = Greeter.new
message = greeter.send(:hello, "World")  # message will be "Hello, World!"
puts message

message = greeter.send("goodbye", "World") # message will be "Goodbye, World!"
puts message

The method name (`:hello` or `”goodbye”`) is passed as an argument to send(), providing flexible method invocation, even based on dynamic conditions. However, caution is crucial when using send() with untrusted input to prevent security vulnerabilities.

Practical Applications of call() and send()

call() and send() offer distinct advantages:

• call(): Ideal for creating callable objects, implementing strategies (e.g., different sorting algorithms), and working with functional programming concepts like lambdas and procs. It provides cleaner, more readable syntax than send() for predefined methods.
• send(): Useful for metaprogramming, dynamic method dispatch based on runtime conditions, and building flexible APIs. It’s particularly helpful when the method name is unknown at compile time. However, overuse can reduce code readability and maintainability.

Example: Strategy Pattern with call()

class SortStrategy
  def call(array)
    raise NotImplementedError, "Subclasses must implement the call method"
  end
end

class BubbleSort < SortStrategy
  def call(array)
    # Bubble sort implementation... (Implementation omitted for brevity)
  end
end

class QuickSort < SortStrategy
  def call(array)
    # Quick sort implementation... (Implementation omitted for brevity)
  end
end

sorter = BubbleSort.new
sorted_array = sorter.call([3, 1, 4, 1, 5, 9, 2, 6])

This demonstrates how call() elegantly implements the Strategy pattern.

Conclusion

call() and send() are powerful Ruby tools. call() offers a clean, functional approach to creating callable objects, while send() provides dynamic method invocation. Understanding their strengths and weaknesses enables developers to select the appropriate method for each task, improving code flexibility and maintainability. Use send() cautiously, especially with untrusted input, to mitigate security risks.

FAQ

• Q: What are the security implications of using send()?
  A: Using send() with untrusted input can enable malicious execution of arbitrary methods, creating vulnerabilities. Always sanitize and validate input before using send().
• Q: Can I use call() with any method?
  A: No, call() is specifically for methods named call().
• Q: Is send() faster than directly calling a method?
  A: No, send() involves a lookup, making it slower. Use it only when dynamic invocation is necessary.
• Q: What’s the difference between send and public_send?
  A: public_send only calls public methods, enhancing security by preventing access to private/protected methods. send can call methods of any visibility.