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?

The NoMethodError Exception is raised .

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

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)

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