Send for calling methods dynamically in Ruby - Step-by-Step Execution

Concept Flow - Send for calling methods dynamically

Start

↓

Have object

↓

Call send with method name as symbol/string

↓

send looks up method

↓

Method executed on object

↓

Return method result

↓

End

The send method takes a method name and calls that method on the object dynamically, returning the result.

Execution Sample

Ruby

class Greeter
  def hello
    "Hi!"
  end
end

obj = Greeter.new
puts obj.send(:hello)

This code calls the hello method dynamically on obj using send and prints the result.

Execution Table

Step	Action	Evaluation	Result
1	Create Greeter class with hello method	Defined class Greeter with method hello	Class ready
2	Create obj = Greeter.new	obj is new Greeter instance	obj created
3	Call obj.send(:hello)	send looks for method :hello on obj	Method found
4	Execute hello method	hello returns "Hi!"	"Hi!" returned
5	puts prints result	Output to console	Hi! printed

💡 send completed method call and returned result

Variable Tracker

Variable	Start	After 1	After 2	After 3	Final
obj	undefined	Greeter instance	Greeter instance	Greeter instance	Greeter instance
result	undefined	undefined	undefined	"Hi!"	"Hi!"

Key Moments - 3 Insights

Why do we use a symbol :hello instead of a string "hello" in send?

send accepts both symbols and strings, but symbols are preferred for method names because they are more efficient and commonly used in Ruby. See execution_table step 3 where :hello is passed.

What happens if the method name passed to send does not exist?

Ruby raises a NoMethodError because send tries to call a method that is not defined on the object. This is not shown here but would stop execution after step 3.

Can send call private methods?

Yes, send can call private and protected methods, bypassing normal access control. This is a powerful feature but should be used carefully.

Visual Quiz - 3 Questions

Look at the execution_table, what is the result of obj.send(:hello) at step 4?

A "Hi!"

B NoMethodError

C nil

D "hello"

💡 Hint

Check the 'Result' column at step 4 in execution_table

At which step does send look up the method on the object?

A Step 2

B Step 3

C Step 4

D Step 5

💡 Hint

Look at the 'Action' and 'Evaluation' columns in execution_table for method lookup

If we change send(:hello) to send(:bye), what will happen?

A It will print nil

B It will print "Hi!" anyway

C It will raise NoMethodError

D It will call hello method

💡 Hint

Refer to key_moments about what happens if method does not exist

Concept Snapshot

Use send to call methods dynamically on an object.
Syntax: object.send(:method_name, args)
Method name can be symbol or string.
send bypasses access control (can call private methods).
Returns the method's result.
Raises error if method missing.

Full Transcript

This visual execution shows how Ruby's send method calls methods dynamically. First, a Greeter class with a hello method is defined. Then an object obj is created from Greeter. When obj.send(:hello) is called, send looks up the hello method on obj, executes it, and returns "Hi!". The puts prints this result. Variables obj and result change as the code runs. Beginners often wonder why symbols are used, what happens if the method is missing, and if send can call private methods. The quizzes check understanding of these steps and outcomes.

Practice

1. What does the Ruby method send do when used like obj.send(:method_name)?

easy

A. Calls the method named method_name on obj dynamically.

B. Creates a new method called method_name on obj.

C. Deletes the method named method_name from obj.

D. Returns the name of the method as a string.

Solution

1. Step 1: Understand send usage

   The send method calls a method on an object using the method's name given as a symbol or string.

2. Step 2: Analyze the example obj.send(:method_name)

   This calls the method named method_name on obj dynamically at runtime.

3. Final Answer:

   Calls the method named method_name on obj dynamically. -> Option A

4. Quick Check:

   send calls methods dynamically [OK]

Hint: Remember: send calls methods by name on objects [OK]

Common Mistakes:

• Thinking send creates or deletes methods
• Confusing send with method name retrieval
• Assuming send returns method names as strings

2. Which of the following is the correct syntax to call a method named greet on object user using send?

easy

A. user.send(greet)

B. user.send('greet')()

C. user.send['greet']

D. user.send(:greet)

Solution

1. Step 1: Recall send syntax

   The method name should be passed as a symbol or string without parentheses after send.

2. Step 2: Check each option

   user.send(greet) misses quotes or symbol, causing error. user.send(:greet) correctly uses a symbol :greet. user.send('greet')() wrongly adds parentheses after send call. user.send['greet'] uses incorrect bracket syntax.

3. Final Answer:

   user.send(:greet) -> Option D

4. Quick Check:

   Use symbol for method name in send [OK]

Hint: Use colon before method name symbol in send [OK]

Common Mistakes:

• Passing method name without quotes or colon
• Adding parentheses after send call
• Using brackets [] instead of parentheses ()

3. What is the output of this Ruby code?

class Person
  def greet(name)
    "Hello, #{name}!"
  end
end

p = Person.new
puts p.send(:greet, "Alice")

medium

A. Hello, Alice!

B. greet

C. NoMethodError

D. Hello, name!

Solution

1. Step 1: Understand the method call with send

   The send method calls greet on p with argument "Alice".

2. Step 2: Evaluate the method output

   The greet method returns "Hello, Alice!" which is printed by puts.

3. Final Answer:

   Hello, Alice! -> Option A

4. Quick Check:

   send calls greet with argument "Alice" [OK]

Hint: send passes arguments after method name [OK]

Common Mistakes:

• Expecting method name string as output
• Confusing argument passing with no arguments
• Thinking send returns method object

4. Identify the error in this Ruby code snippet:

class Calculator
  def add(a, b)
    a + b
  end
end

calc = Calculator.new
calc.send(:add, 5)

medium

A. send cannot be used with arguments

B. Method add does not exist

C. Missing second argument for method add

D. Syntax error in method definition

Solution

1. Step 1: Check method definition

   The method add requires two arguments: a and b.

2. Step 2: Analyze the send call

   The send call provides only one argument (5), missing the second argument.

3. Final Answer:

   Missing second argument for method add -> Option C

4. Quick Check:

   Method arguments must match when using send [OK]

Hint: Match method arguments count when using send [OK]

Common Mistakes:

• Passing fewer arguments than method requires
• Assuming send works without correct arguments
• Thinking send changes method signature

5. You want to call different arithmetic methods (add, subtract, multiply) on a Calculator object dynamically based on user input stored in operation. Which Ruby code correctly uses send to achieve this?

class Calculator
  def add(a, b); a + b; end
  def subtract(a, b); a - b; end
  def multiply(a, b); a * b; end
end

calc = Calculator.new
operation = :multiply
# Fill in the blank below to call the method dynamically
result = ???
puts result

hard

A. calc.send(:operation, 4, 5)

B. calc.send(operation, 4, 5)

C. calc.send('operation', 4, 5)

D. calc.send(operation())

Solution

1. Step 1: Understand dynamic method calling

   The variable operation holds the symbol of the method to call.

2. Step 2: Use send with variable method name and arguments

   Passing operation as the first argument to send calls the correct method with arguments 4 and 5.

3. Final Answer:

   calc.send(operation, 4, 5) -> Option B

4. Quick Check:

   send uses variable method names with arguments [OK]

Hint: Pass method name variable and args directly to send [OK]

Common Mistakes:

• Passing method name as string literal instead of variable
• Adding parentheses after variable name incorrectly
• Using symbol literal instead of variable for method name