Method_missing for catch-all in Ruby - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to define a method that catches calls to undefined methods.

Ruby

def [1](method_name)
  puts "You called #{method_name}!"
end

Drag options to blanks, or click blank then click option'

Amethod_missing

Bundefined_method

Cmissing_method

Dcatch_all

Attempts:

3 left

💡 Hint

Common Mistakes

Using a method name other than 'method_missing' will not catch undefined methods.

The method_missing method in Ruby is called when an undefined method is invoked on an object.

2fill in blank

medium

Complete the code to print the name of the missing method and its arguments.

Ruby

def method_missing(method_name, *[1])
  puts "Called #{method_name} with #{args.inspect}"
end

Drag options to blanks, or click blank then click option'

Aargs

Bparams

Carguments

Dvalues

Attempts:

3 left

💡 Hint

Common Mistakes

Using a variable name other than 'args' without updating the code inside the method.

The splat operator *args collects all arguments passed to the missing method into an array named args.

3fill in blank

hard

Fix the error in the method_missing definition to correctly handle missing methods with arguments.

Ruby

def method_missing(method_name, [1])
  puts "Missing method: #{method_name}"
end

Drag options to blanks, or click blank then click option'

Aparams

Bargs

C*args

D&block

Attempts:

3 left

💡 Hint

Common Mistakes

Omitting the splat operator causes argument errors when multiple arguments are passed.

The splat operator *args is needed to capture any number of arguments passed to the missing method.

4fill in blank

hard

Fill both blanks to define method_missing that prints method name and block presence.

Ruby

def method_missing(method_name, *args, &[1])
  if [2]
    puts "Block given to #{method_name}"
  else
    puts "No block given to #{method_name}"
  end
end

Drag options to blanks, or click blank then click option'

Ablock

Bargs

Cblock_given?

Dmethod_name

Attempts:

3 left

💡 Hint

Common Mistakes

Not capturing the block argument or not checking for block presence correctly.

The &block captures an optional block passed to the method. The block_given? method checks if a block was provided.

5fill in blank

hard

Fill all three blanks to define method_missing that logs method name, arguments, and returns a default message.

Ruby

def method_missing([1], *[2], &block)
  puts "Called #{method_name} with #{args.inspect}"
  "Default response for #[3]"
end

Drag options to blanks, or click blank then click option'

Amethod_name

Bargs

Dparams

Attempts:

3 left

💡 Hint

Common Mistakes

Using inconsistent variable names or missing the splat operator for arguments.

The method parameters are method_name for the method called, *args for arguments, and &block for an optional block. The method returns a default string including the method name.

Practice

1.

What is the main purpose of the method_missing method in Ruby?

easy

A. To catch calls to methods that do not exist and handle them dynamically.

B. To define a method that always returns nil.

C. To automatically create getter and setter methods.

D. To override existing methods with new behavior.

Solution

1. Step 1: Understand what method_missing does

   method_missing is called when an object receives a method call it does not have defined.

2. Step 2: Identify its purpose

   It allows handling these unknown method calls dynamically, enabling flexible behavior.

3. Final Answer:

   To catch calls to methods that do not exist and handle them dynamically. -> Option A

4. Quick Check:

   method_missing catches unknown methods [OK]

Hint: Remember: method_missing handles calls to undefined methods [OK]

Common Mistakes:

• Thinking method_missing defines new methods automatically
• Confusing method_missing with attr_accessor
• Assuming method_missing overrides existing methods

2.

Which of the following is the correct syntax to define method_missing in a Ruby class?

class Example
  # Your code here
end

easy

A. def method_missing(method_name)
puts "Unknown method: #{method_name}"
end

B. def method_missing(method_name, args)
puts "Unknown method: #{method_name} with args: #{args}"
end

C. def method_missing(method_name, *args)
puts "Unknown method: #{method_name} with args: #{args}"
end

D. def method_missing(*args)
puts "Unknown method called"
end

Solution

1. Step 1: Recall method_missing signature

   The method receives the missing method's name as a symbol and any arguments as a splat array.

2. Step 2: Check each option's parameters

   def method_missing(method_name, *args) puts "Unknown method: #{method_name} with args: #{args}" end correctly uses method_name, *args to capture method name and all arguments.

3. Final Answer:

   def method_missing(method_name, *args) puts "Unknown method: #{method_name} with args: #{args}" end -> Option C

4. Quick Check:

   Correct parameters = def method_missing(method_name, *args) puts "Unknown method: #{method_name} with args: #{args}" end [OK]

Hint: method_missing needs method name and splat args [OK]

Common Mistakes:

• Forgetting the splat (*) before args
• Using only one parameter for method_missing
• Passing args without splat causing errors

3.

What will be the output of this Ruby code?

class CatchAll
  def method_missing(name, *args)
    "Called #{name} with #{args.join(', ')}"
  end
end

obj = CatchAll.new
puts obj.hello('world')

medium

A. hello

B. Called hello with world

C. NoMethodError

D. Called method_missing with hello

Solution

1. Step 1: Understand method_missing behavior

   The method_missing catches the call to hello which is undefined and returns a string with method name and arguments.

2. Step 2: Evaluate the output

   Calling obj.hello('world') triggers method_missing with name :hello and args ['world'], so output is "Called hello with world".

3. Final Answer:

   Called hello with world -> Option B

4. Quick Check:

   method_missing output = Called hello with world [OK]

Hint: method_missing returns string with method name and args [OK]

Common Mistakes:

• Expecting NoMethodError instead of method_missing output
• Confusing method name symbol with string
• Ignoring args passed to method_missing

4.

Identify the error in this Ruby class using method_missing:

class Test
  def method_missing(name)
    puts "Missing: #{name}"
  end
end

Test.new.unknown_method(1, 2)

medium

A. method_missing should accept a splat argument for extra parameters.

B. method_missing must return a value, not puts.

C. method_missing cannot be defined in a class.

D. No error; code runs fine.

Solution

1. Step 1: Check method_missing parameters

   The call unknown_method(1, 2) passes two arguments, but method_missing only accepts one parameter name.

2. Step 2: Identify the fix

   To handle any number of arguments, method_missing must accept *args as a splat parameter.

3. Final Answer:

   method_missing should accept a splat argument for extra parameters. -> Option A

4. Quick Check:

   Missing splat args causes error [OK]

Hint: Add *args to method_missing to catch all parameters [OK]

Common Mistakes:

• Ignoring extra arguments passed to missing method
• Assuming puts return is enough
• Thinking method_missing can't be defined in classes

5.

Given this class, what will obj.foo.bar(1) output?

class CatchAll
  def method_missing(name, *args)
    if name == :bar
      "Handled bar with #{args[0]}"
    else
      self
    end
  end
end

obj = CatchAll.new
puts obj.foo.bar(1)

hard

A. NoMethodError for foo

B. Handled bar with nil

C. self

D. Handled bar with 1

Solution

1. Step 1: Trace obj.foo call

   Calling obj.foo triggers method_missing with name=:foo, which returns self (the object itself).

2. Step 2: Trace .bar(1) call on returned self

   Calling .bar(1) triggers method_missing with name=:bar and args [1], which returns "Handled bar with 1".

3. Final Answer:

   Handled bar with 1 -> Option D

4. Quick Check:

   Chained method_missing returns handled string [OK]

Hint: method_missing can return self to chain calls [OK]

Common Mistakes:

• Expecting NoMethodError on first call
• Not realizing method_missing returns self for chaining
• Assuming args are missing for bar method