Khaled alHabache's official blog » reflection

Ruby reflection 2

khelll — Sat, 27 Dec 2008 07:00:04 +0000

This is the second post related to ruby’s reflection API, the previous post was an extensive intro to this topic. While the current one will be lighter somehow, it would require you to focus a bit more on the content.
Here we go:

Setting, getting and removing instance variables :

# Define a simple class M
class M ; end #=> nil
 
m = M.new #=> #
 
# Set an attribute i with value 5, the attribute name should be a symbol prefixed with @
m.instance_variable_set :@i , 5 #=> 5 
 
# This will never work cause no attribute reader is defined for 'i'
m.i #=>NoMethodError: undefined method `i' for # from (irb):4
 
# Get it the right way!
m.instance_variable_get :@i #=> 5

The code above could be written in a simpler way, let’s define another attribute ‘v’ for example :

# Use class_eval , and pass it a block of code :
M.class_eval { attr_accessor :v} #=> nil
 
# Set and get the attribute v
m.v = 8 #=> 8
m.v #=> 8

Now, let’s undefine the instance variable ‘i’

m.remove_instance_variable :@i  #=>NoMethodError: private method `remove_instance_variable' called for #
 
# Opps, a private method! let's bypass that with instance_eval
m.instance_eval{remove_instance_variable :@i} #=> 5      ,
 
# Could be accomplished with :send
m.send :remove_instance_variable , :@i #=>5
m.i #=> nil

Setting, getting and removing class variables :

As instance_variable_get and instance_variable_set, there are another variations applied to class variables, but unfortunately they are private in ruby 1.8, so let’s use class_eval to bypass that:

M.class_eval {class_variable_set :@@ci ,1} #=> 1
M.class_eval {class_variable_get :@@ci} #=> 1
M.class_eval {remove_class_variable :@@ci } #=> 1

Setting, getting and removing constants :

How about constants?

M.const_set :CON , "I'm a constant" #=> "I'm a constant"
M.const_get :CON #=> "I'm a constant"
M.const_defined? :CON #=> true
 
 
# Let's remove it with "send" method
M.send :remove_const , :CON #=> "I'm a constant"
M.const_defined? :CON #=> false

define_method

Now let’s move to a new topic:
Define a method dynamically using define_method:
As the API tells :

Defines an instance method in the receiver. The method parameter can be a Proc or Method object. If a block is specified, it is used as the method body. This block is evaluated using instance_eval, a point that is tricky to demonstrate because define_method is private.

# define_method is a private method, that's why we use the 'class_eval' method
String.class_eval {define_method(:len){length}} #=> #
"how much long am I?".len #=> 19
 
# You can use the 'send' method instead of 'class_eval', notice how we are sending a Proc object to define_method
String.send :define_method,:len2,lambda {length}
"how much long am I?".len2 #=> 19

When using a block, the block params will be the method params:

String.class_eval{define_method(:part){|s,e| self[s,e] } } #=> #
"hello world!".part(1,4) #=> "ello"

Let’s use it to redefine the ‘attr_access’ in another way rather than the way that was defined in the previous post

class Class
  def attr_access(*attrs)
    attrs.each do |attr|
      define_method :"#{attr}=" do |value|
        instance_variable_set("@#{attr}",value) 
      end
 
      define_method :"#{attr}" do
        instance_variable_get "@#{attr}"
      end
    end
  end
end

One limitation to ‘define_method’ is that: it always creates instance methods, thus if we want to use it to define class methods, then we need to invoke it on the singleton class, let’s define the ‘cattr_access’ method:

class Class
   def cattr_access(*attrs)
    singleton_class = class << self; self; end
    attrs.each do |attr|
      singleton_class.class_eval do 
        define_method :"#{attr}=" do |value|
          class_variable_set("@@#{attr}",value)
        end
        define_method :"#{attr}" do
          class_variable_get "@@#{attr}"
        end
      end
    end
  end
end

Notice how i defined the singleton_class as a local variable, it could be defined using a method, just like what we did in the previous post, however, notice: how complex it became to use the define_method to define a class method, i wouldn’t encourage at all such a complexity.

Undefining methods

How about undefining methods? That can be accomplished in 2 ways: either by using the ‘undef’ statement, or using the private ‘undef_method’ method:

String.class_eval{undef :len} #=> nil
String.send :undef_method ,:len2 #=> String

Alias chaining

One last thing that deserves mentioning here: is the ‘alias_method’, it’s being used to have alias chaining:
1- Copy the original method and give it an alias to be used later.
2- Create a new method with the same name of the original one, do whatever changes you need, and use the alias to invoke the original method somewhere inside the new one.
Before i show you the example i have to mention the ruby statement ‘alias’ which can be used as ‘alias_method’ :

# I want to modify the 'puts' method to make it more expressive, at least for me!
#' puts' is defined in Kernel module.
# Copy the method "puts", and assign it a new name: "original_puts"
alias :original_puts :puts #=> same as doing:   Kernel.send :alias_method ,:original_puts ,:puts
 
# Now define the method again, and use the original method functionality to help expressing the new functionality. 
def puts(*args)
   args.each_with_index do |arg,index|
	original_puts "value of parameter #{index+1} =>  #{arg}"
   end
end
 
puts 1,2,3
#value of parameter 1 =>  1
#value of parameter 2 =>  2
#value of parameter 3 =>  3

I hope you liked this post, please don’t hesitate to notify me about hidden mistakes or suggest new stuff.
I’ll blog on using ruby’s hooks(callbacks) in the next blog post, stay in touch…..

Ruby reflection

khelll — Fri, 19 Dec 2008 22:23:28 +0000

If you are here, then most probably you want to know more about ruby reflection interface. Well that’s true, but I always find myself in need to explain few things before I get started with my posts, and this time I find myself in need of explaining few things related to ruby’s OOP.

I’m pretty sure that you always heard that “in ruby: everything is an object.” , but have you ever thought of that carefully?
The first thing that comes to a one’s mind is something like :

5.class #=> Fixnum
"hello".class #=> String

But have you thought of your class as an object? Well that seems odd, but that’s how ruby works:

class Foo;end  #=> nil
Foo.class #=> Class

What does the above snippet of code mean exactly?
It means 2 things : Foo is a constant and that constant holds(refers to) an object of Class type.

Let me prove that 2 you:

Foo = Class.new
(irb):8 warning: already initialized constant Foo
=> Foo

As you can see, I got a warning because I tried to initialize the constant Foo again.

So ,when you define some class ‘Foo’ in ruby, all you are doing is:
1-instantiating an object of type Class.
2-initializing a constant Foo that refers to that created object .

So bear in mind that when I say “object” ,then I do mean any object; an object of Class type, or any object of any type.

Now, let’s move to another point. What about the ‘Singleton Class’, did you have the chance to work with it before?
Simply it’s the class that holds all singleton methods of an object, whether it’s a class object , or any other object.

Let’s start by defining 2 class methods (a class method is nothing but: a singleton method of an object of Class type) :

class Foo
  def self.hi ; p "hi" ;end
  def self.bye ; p "bye" ; end
end
Foo.singleton_methods #=> ["hi","bye"]

You could also have written that in this way:

class Foo
  class << self
    def hi ; p "hi" ; end
    def bye ; p "bye" ; end
  end
end
Foo.singleton_methods #=> ["hi","bye"]

The above inner class mentioned with “class << self" is what we call : a singleton class.
Let's define a method that returns back the singleton class for us :

class Object
  def singleton_class 
     class << self
       self
     end
  end
end

Now try this :

Foo.singleton_methods #=> ["bye", "hi"]
Foo.singleton_class.instance_methods(false) #=> ["bye", "hi"]

As you can see, the singleton class is the class that holds all singleton methods.
We will use the singleton class later in this series, so keep the concept in mind.

Let’s now get back to our topic on ruby’s reflection api , i will introduce 3 methods in this post: eval , instance_eval and class_eval.

eval

‘eval’ is a method that evaluates a ruby string :

eval "3+4" #=> 7
eval "def multiply(x,y) ; x*y; end"
multiply(4,7) #=> 28

eval can also work in the scope of bindings ; a binding is an object that encapsulates the execution context at some particular place in the code and retain this context for future use. Look at this example of using bindings with eval :

class Demo
  def initialize(n)
    @secret = n
  end
  def getBinding
    return binding()# a method defined in Kernel module
  end
end
k1 = Demo.new(99)
#get the value of the instance variable @secrete stored in the binding of object k1
eval("@secret", k1.getBinding)   #=> 99

Also can work with proc objects :

def greeting(name)
  lambda{|greetings| greetings.collect {|g| "#{g} #{name}"} }
end
greeter = greeting("dude") #=> #
greeter.call ["hi","hello","hola"] #=> ["hi dude", "hello dude", "hola dude"]
eval("name='khelll'",greeter) #=> "khelll"
greeter.call ["hi","hello","hola"] #=> ["hi khelll", "hello khelll", "hola khelll"]

instance_eval

This method works in the context of the object :

class Klass
  def initialize
    @secret = 99
   end
end
k = Klass.new
k.instance_eval { @secret }   #=> 99 , notice the @

And could be used to define singleton methods :

Fixnum.instance_eval "def zero; 0 ;end"                                                 
Fixnum.zero #=> 0

you can pass it a block instead of the string :

Fixnum.instance_eval{ def ten ;10;end }
Fixnum.ten #=> 10

class_eval

Evaluates a string or a block in the context of the receiver

Foo.class_eval{@@x=1} #=> 1
Foo.class_eval{@@x} #=> 1

And it defines instance methods when called on some object

Fixnum.class_eval "def number ; self ;end"
5.number #=> 5

And as instance_eval, a block instead of the string could be passed

Fixnum.class_eval{ def number;self;end}
7.number #=> 7

You can use class_eval to dynamically use private methods, for example to use the private method ‘include’:

module M; end
String.include M #=> NoMethodError: private method `include' called for String:Class
String.class_eval{include M} #=> you could do it with String.send(:include,M)

Now let’s make use of our knowledge,let’s try to redefine the attr_accessor method in our way, I will make a similar method called attr_access :

class Class
  def attr_access(*attrs)
    attrs.each do |attr|
      class_eval %Q{
	    def #{attr} 
	      @#{attr}
	    end
	    def #{attr}=(value)
	      @#{attr} = value
	    end
      }
    end
  end
end
 
class Foo 
 attr_access :a,:b 
end
 
Foo.instance_methods(false) #=> ["b=", "a=", "b", "a"]

in a similar way we can define class attribute accessors :

class Class
    def cattr_access(*attrs)
      attrs.each do |attr|
        class_eval %Q{
  	    def self.#{attr}
  	      @@#{attr}
  	    end
  	    def self.#{attr}=(value)
  	      @@#{attr} = value
  	    end
        }
      end
    end
end

Or with we can use the singleton class :

class Class
  def singleton_class 
    class << self
      self 
    end 
  end
 
  def cattr_access(*attrs)
    attrs.each do |attr|
      singleton_class.class_eval %Q{
        def #{attr}
  	   @@#{attr}
  	 end
  	 def #{attr}=(value)
  	    @@#{attr} = value
  	 end
       }
    end
  end
end

And in both cases we can do :

class Foo ; cattr_access :cx,:cy end
Foo.singleton_methods(false) #=> ["cy", "cy=", "cx", "cx="]

Give it a try and try to define attr_reader and attr_writer for both object and class variables.

I think it’s enough for this post, the next post will contain more methods to look at. See you then.

Update 1: fixing some typos.
Update 2: second part is here.