Dynamic method in ruby

In Ruby, the dynamic nature of method dispatch is one of its key features. Method calls are resolved at runtime based on the actual type of the object. This flexibility allows for polymorphic and dynamic behavior

Dynamic Dispatch

class Number def square(argument) argument ** 2 end def cube(argument) argument ** 3 end end number = Number.new number.square(3) #=> 9 

Method can be called using dot notation but this restricts making the method call being dynamic.

class.method("method_name").call is way to invoke a method but is not a common pattern because it involves a more indirect and less flexible approach compared to other dynamic method invocation techniques.

There is another way to call a method that is using send. It accepts method name and the method’s arguments as it own arguments.

number.send(:square, 3) #=> 9 

Since the method name is an argument it can be replaced by any method name during runtime.

puts "Enter a number:" user_input = gets.chomp puts "Enter the method name:" method_name = gets.chomp number.send(method_name.to_sym, 4) #=> 16 

to_sym is used to convert string to symbol but method name can be passed as string. Using send to dispatch a method has a downside when it comes to privacy concerns as it invokes even a private method of the class without throwing an error. This can be prevented using by using public_send.

We can not only call methods during runtime but also define methods during runtime.

Dynamic Methods

A method can be defined using define_method at the run time.

class Number define_component(method_name, argument, power) define_method(method_name) do |argument, power| argument ** power end end end number = Number.new number.define_component(square,4, 2) #=> 16 number.define_component(cube,4, 3) #=> 64 

There is another way of defining methods dynamically using method_missing.

Ghost Method

What happens when you call a method on an object that is not yet defined. A method missing error is displayed. What happens internally is ruby goes up the object hierarchy and checks up till BasicObject and when the method is not found it transfers the call to method_missing in BasicObject class, which returns NoMethodError.

class Book end book = Book.new book.author #=>undefined method `author' for #<Book:0x00005585e38e9720> (NoMethodError) 

We can override this method and return what we want to.

class Book def method_missing(method, args) "All missing methods return this string" end end book = Book.new book.author #=>"All missing methods return this string" 

method_missing comes with huge advantage when there are many methods with similar definition. It saves the time of writing them and testing them independently.

Cons

1. Readability and maintainability of code.
2. Security issues arise when method name is taken from input.
3. When the method which is supposed to be missing is found in ancestors chain.
4. Debugging would be complex.

Conclusion

It is worth noting that while these dynamic features of ruby are powerful they should be used with caution, considering trade-offs.