CSC/ECE 517 Fall 2007/wiki1b 2 c9

CSC- 517 Object-Oriented Languages and Systems

                                     Wiki Assignment

Topic 2 : There are plenty of examples of method_missing on the Web. Unfortunately, I find most of them rather difficult to understand. One needs to look at quite a bit of source code and figure out what it does. Fix this by giving a plain-English description of several uses of method_missing not covered in our class, with Web links to the pages where you found them.

Ruby has a powerful way to intercept calls to undefined method. This is implemented by defining method_missing in our class definition. If a call is made to an undefined method on a object, Ruby passes the name of the method and its arguments to the method_missing. This is an efficient and safest way to intercept calls made to unknown methods and handles them in a proper fashion. Let us look into few examples (Source: http://rubylearning.com/satishtalim/ruby_method_missing.html

class Dummy  
def method_missing(m, *args)   
puts "There's no method called #{m} here, please try again."  
end  
end  

Dummy.new.anything >ruby tmp.rb Output: There's no method called anything here, please try again. In the above example, a call is made to a method called anything on object of class Dummy. There is no method called “anything” defined within the class. Ruby passes the name “anything” to method_missing. Hence the above output is displayed.

In the following example, method method_missing intercepts and prints out a message with method name and argument list (if any) and forwards on the method call using 'send' method without knowing anything about the object passed to it. (source: http://blog.mauricecodik.com/2005/12/more-ruby-methodmissing.html)

 class SimpleCallLogger
   def initialize(o)
     @obj = o
   end
   def method_missing(methodname, *args)
     puts "called: #{methodname}(#{args})"
     a = @obj.send(methodname, *args)
     puts "\t-> returned: #{a}"
     return a
   end
 end

Another use of method_missing: (Source: http://redhanded.hobix.com/inspect/theBestOfMethod_missing.html)

  def method_missing(method)
    @posts = User.find_first(['username = ?', method.to_s]).posts
    render_action 'index'    
    cache_page if ActionController::Base.perform_caching
  end

The above code is an example of a controller used for generating RSS and Atom Feeds to user. It is used by Elite Journal which is a multi user. Since their web page changes display every now and then depending upon the status of user login. Therefore caching the output is very hard. Therefore, most of the time the output is not cached. So, generally the RSS and Atom Feeds are cached. Since Elite Journal is multi-user, there is a feed for each user. This feed is combined with the method_missing call such that a call to the /rss/scott URL will retrieve the feed to the user “Scott”. In the above example, the page is cached if caching is enabled by the action controller. Another set of example for the use of method_missing is as follows: (Source: facets.rubyforge.org/src/lib/facets/core/kernel/as.rb)

 def method_missing(sym, *args, &blk)
   @ancestor.instance_method(sym).bind(@subject).call(*args,&blk)
   end
   require 'rubygems'
   require 'facets'

   module James
   def name
     "James"
   end
 end

 module Lynn
   def name
     "Lynn"
   end
 end

 class FamilyMember
   include James
   include Lynn
 end

FamilyMember.ancestors # => [FamilyMember, Lynn, James, Object, Kernel] member = FamilyMember.new member.name # => "Lynn" member.as(James).name # => "James"

In above example method_missing definition allows you to call a method on any ancestor. Initially instance of FamilyMember i.e member receives a message as which returns an instance of As. After returning the instance of As, member receives messae “name”. Since As does not contain the definition of name, the method_missing is called where in name is passed as an arguments. Within the method, instance_method is called on the ancestor with the name as the symbol. The instance_method will return the unbound method name since it is not defined. Then, method_missing binds the name to the subject which is member (instance of FamilyMember) and sends a call message along with the arguments passed before. Here, since name binds to the member, it can access the state or behavior of the member. Last example for the purpose of using method_missing. (source: http://services.tucows.com/developers/2007/08/03/rubys-method_missing-method-explained-with-lolcats/)

 class LolCat
   def confess
     puts “I made you a cookie…but then I eated it.”
   end

   def eat
     puts “NOM NOM NOM.”
   end

   def method_missing(method)
     puts “Oh noes! I has no idea how to #{method}.”
   end
 end

> kitty = LolCat.new => #<LolCat:0x349a40>

> kitty.confess I made you a cookie...but then I eated it. => nil

> kitty.eat NOM NOM NOM. => nil

> kitty.poop Oh noes! I has no idea how to poop. => nil

In the above example, we create an instance of LolCat which is named kitty. Next, call the method “confess” on kitty. Since it is defined , the method “confess” is called and appropriate result is printed. When the method poop is called, the method_missing is called since the method “poop” is not defined. Ruby passes the name of the method i.e “confess” and arguments that are needed to the method “poop”. The method_missing displays an error accordingly.