CSC/ECE 517 Fall 2012/ch1 1w22 an

Introduction

When we define a method in a class and decide to call that method, how do we do it?

We simply create an object of the class and pass the method name to the object as a message. The object then looks up into its method lookup path and tries to match the called method (passed as a message to the object) with the defined methods in the class. When there is a match, the method is executed along with the parameters passed and the result is returned.

What is a Method Lookup Path?

When the object receives a method name that is to be executed, these are the steps carried out for finding out that method called:

• It looks in the current self object’s own instance methods.
• Then it looks in the list of instance methods that all objects of that class share.
• Then in each of the included modules of that class, in reverse order of inclusion.
• Then it looks in that class’s superclass.
• Then in the superclass’s included modules, all the way up until it reaches the class Object.
• If it still can’t find a method, the very last place it looks is in the Kernel module, included in the class Object.
• Finally, it calls method_missing (if defined in the class), else throws up the NOMethodError exception.

This entire tracing that the object does is the method lookup path.

What is method_missing?

Now suppose that the object does not find a matching method in its method lookup path i.e there is no such method defined in the class. Then what?

In normal circumstances the NoMethodError Exception is raised .

Here is where the method_missing comes into picture. The name “method_missing” should be self explanatory that it is invoked when a method is not found. It is a method of last resort. This method accepts the name of the non-existing method, the array of arguments passed and also any associated block to the method.

The format for defining method_missing

=> def method_missing(m,*args,&block)

Examples

A Simple Illustration

class A			// creating a class A
def say			// defining a method say
puts " say Hi "
end
end

Now, creating the object of the class

 a=A.new	         // object of the class
 => #<A:0x2a082e0>      //object id

Calling the defined method

a.say                  // defined method
=> say Hi		       // returned result

Calling the undefinedd method

a.sayhi                  // undefined method
NoMethodError: undefined method `sayhi' for #<A:0x2a082e0>   // the NoMethodError is raised

method_missing implementation

class A
def say
puts " say hi "
end
def method_missing(m,*args,&block)		// defining method_missing
puts " This method does not exist"		// body of method_missing
end
end

Calling a method that is not defined

a=A.new
a.sayhi
=> This method does not exist		// this result returned when method_missing is executed

>> Explanation: When the object 'a' traces its method lookup path for a matching method as 'sayhi', after a failure it resorts to method_missing and the body of method_missing is executed.

Note: There is something interesting that programmers do. Sometimes when a class has many methods that do generally the same kinds of things, and the programmer is not sure in advance which methods will the user call since there are so many of them, and they are all so similar, implementing all of them by hand seems futile. In these situations method_missing makes a new method that was previously not defined and adds it to the class ; or it just does what needs to be done, this is in the hands of the programmer.

Now, let us look into a few more examples to get the concept right.

passing parameters to an undefined method

class A
def add(a,b)
a+b
end
def method_missing(name,*args,&block)    // the method_missing is defined and the *args parameter accepts all the parameters passed during 								                                 
                                            the method call   
puts “You have typed the method name wrong and these were the parameters passed ; #{args[0]}, #{args[1]}”								
end                         			
end

the passed parameters are stored in the array 'args' and can be accessed like a normal array

Calling the defined method

a.add(1,2)			// calling the defined method add and passing the parameters (1,2)
=> 3                           // result

Calling the undefined method

a.adds(4,2) 			// calling the undefined method adds and passing the parameter (4,2)
=> You have typed the method name wrong and these were the parameters passed; 4, 2