Ruby Eval

O nome eval tem origem na palavra inglesa evaluation, que em uma tradução livre significa “avaliar o valor de algo”, no caso de Ruby, o valor de uma expressão ou trecho de código.

No caso de Ruby, a melhor definição seria “interpretar”, devido ao fato que além de avaliar, o código recebido também é executado, como no exemplo abaixo:

eval("puts 'Hello World'") # => Hello World

No post anterior sobre metaprogramação, eu utilizei o método instance_variable_set da classe Object.

Esse método pode ser utilizado para evitar repetições de código. No código abaixo eu mostro como é a implementação desse método e como ele é usado na prática:

Implementação redundante de um construtor de uma classe:

class CalendarEvent
  def initialize(start_time=0, end_time=0, attendees=0)
    @start_time = start_time
    @end_time = end_time
    @attendees = attendees
  end
end

Implementação melhorada com o uso de eval:

#Primeiro, adicionamos o seguinte código à classe Object,
#para torná-lo disponível para as instâncias de quaisquer classe
class Object
  private
  def set_instance_variables(binding, *variables)
    variables.each do |var|
      instance_variable_set("@#{var}", eval(var, binding))
   end
  end
end

#Depois podemos melhorar a nossa classe

class CalendarEvent
  def initialize(start_time=0, end_time=0, attendees=0)
    set_instance_variables(binding, *local_variables)
  end
end

c = CalendarEvent.new(4,5,2)

puts c.instance_eval "@start_time"   # => 4

Em Ruby, temos mais alguns métodos do tipo eval disponível:

* instance_eval
* class_eval
* module_eval

Dentre esses, a diferença básica está no escopo aonde os métodos serão executados: em classes ou instâncias.

Module.class_eval

O método da classe Module, chamado class_eval, nos possibilita executar blocos dentro do escopo de uma classe. Uma possibilidade útil criada por esse método é a de criar dinamicamente métodos a uma classe, como no exemplo do attr_accessor, que é implementado em C, mas se fosse implementado em Ruby seria algo do tipo:

class Class
  def attr_acc(*vars)
    return if vars.empty?
    code = ""
    vars.each do |v|
      # Cria gets para as variaveis
      code << "def #{v}; @#{v}; end;"
      # Cria sets para as variaveis
      code << "def #{v}=(value); @#{v} = value; end;"
    end
    self.class_eval code

  end
end

#podemos criar uma classe que utiliza nossa cópia do attr_acc
class Foo
attr_acc :bar
end

#... e testar pra ver se ela funciona
f = Foo.new
f.bar = "hello"
puts f.bar                  # => hello

Module.module_eval

Na verdade, podemos realizar algo parecido com o exemplo anterior com uma sintaxe levemente diferente usando Mocule.module_eval como no exemplo abaixo, aonde eu crio um método que retorna os 5 primeiro múltiplos de 3:

Fixnum.module_eval do
  def self.multiple_of_three
     [3,6,9,12,15]
  end
end
puts  Fixnum.multiple_of_three
#=> 3
6
9
12
15

É importante ressaltar que no exemplo acima, estamos criando dinamicamente um método na classe Fixnum, e não um método para as instâncias dessa classe, de modo que a chamada abaixo acabará nos retornando uma exceção:

5.multiple_of_three   # =>NoMethodError: undefined method `multiple_of_three' for 5:Fixnum

Object.instance_eval

O método intance_eval, da classe Object, por sua vez implementa a função eval sob o escopo de instâncias.

class Foo
  def initialize
    @bar = 'hey'
  end
  def change_bar
    @bar = "ho!"
  end
end

foo = Foo.new
puts foo.instance_eval "@bar"
foo.change_bar
puts foo.instance_eval "@bar"

Conclusão

Metaprogramação acaba ficando mais claro na medida que começamos a compreender o verdadeiro poder oferecido pela linguagem. Uma ótima fonte de inspiração e estudo é o código de projetos largamente utilizados em Ruby.

É com recursos como esse que o Rails (e outras ferramentas escritas em Ruby) adicionam diversas funcionalidades ao core de Ruby para comtemplar suas “mágicas”.

Machadão, o rei da Metaliteratura

Metaclasses

Lembra daquela frase que dizia que “em Ruby tu é objeto”? Pois é, vamos olhar o seguinte código:

class Zombie
  def self.alive
    puts "i am alive"
  end
end

Zombie.class     # => Class
Zombie.alive      # => "i am alive"
z = Zombie.new
z.class              # => Zombie

Quando definimos uma classe (no caso a Zombie), uma constante (que em Ruby são escritas com a primeira letra em maiúsculo, lembram?) é criada com o mesmo nome para armazenar um objeto do tipo Class. Assim, quando chamamos um método dessa “constante”, essa mensagem é passada para um objeto Class que o representa.

É interessante frisar que objetos não armazenam métodos, apenas classes fazem isso. Então quando invocamos um método de Zombie, na verdade, este método está armazenado em um objeto do tipo Class.

Vamos brincar mais um pouco:

Zombie.to_s      #=> "Zombie"

Ué? De onde esse método saiu se não o definimos?

O que ocorre aqui é que aquele objeto mencionado anteriormente, que representaria uma classe Zombie, recebe no momento de sua criação todos os métodos com o sufixo “self” ( que representam os métodos de classe) e herda todos os métodos da classe Class. Nesse exemplo, to_s é um método da classe Class. Na verdade, a definição de Zombie é uma classe virtual criada dinamicamente para armazenar os métodos da classe. Esses objetos de classe são chamados de Metaclasses.

Resumindo: Uma classe também é um objeto, mas de um tipo bem particular! Mais precisamente, um objeto da classe Class.

Metaprogramação em Ação

Vamoz continuar brincando com a nossa classe Zombie. É possível que criemos variáveis em tempo de execução dentro de apenas uma instância:

z = Zombie.new
z.instance_variable_set("@eyes", 3)
z.eyes                         # =>NoMethodError: undefined method `eyes' for #

Opa, será que não funcionou o nosso exemplo? Na verdade, sim. Só que não possuímos nenhum método de acesso à propriedade @eyes. Podemos garantir isso, através do seguinte método:

z.instance_variables        # =>  ["@eyes"]

Mas como faríamos para acessar a propriedade @eyes de nosso zumbi? Isso nos leva ao próximo tópico:

Classes Singleton

Primeiramente, esqueça completamente o Design Pattern Singleton . As classes Singleton de Ruby só compartilham o nome com este padrão. Singleton class pode ser resumida como uma classe virtual, aonde um objeto de uma classe já definida pode assumir um comportamento particular, diferente de outros objetos da mesma classe. Vejamos abaixo:

def z.eyes
  "I have #{@eyes} eyes"
end

z.eyes   #  => "I have 3 eyes"

Nesse exemplo nós estamos criando um método apenas para a instância(objeto) “z” da classe Zombie. Agora nosso objeto “z” é um classe Singleton, única, com um comportamento próprio. Podemos perguntar para um objeto se ele possui métodos singleton:

z.singleton_methods             #=> ["eyes"]

Certo, vamos pirar mais um pouco na batatinha. Observe este exemplo:

y = Zombie.new

class << y
  def brains_eaten
    "millions"
  end
end

y.singleton_methods        # => ["brains_eaten"]
y.brains_eaten                 #=> "millions"

Essa sintaxe até certo ponto estranha para iniciantes é o jeito Ruby de dizer que você está “abrindo” uma classe singleton do objeto y . Mas as coisas interessantes não param por aí. Podemos fazer Singletons de instâncias de classes como no exemplo a seguir:

class Fixnum
  class << self
    def desc
     puts "another description"
    end
  end
end

Fixnum.desc        # => another description

Ou, para ficar mais familiar, podemos repetir o mesmo exemplo desta maneira, que é bem comum quando manipulamos objetos do ActiveRecord:

class Fixnum
  def self.description
    puts "i am a number"
  end
end

Fixnum.description         # => i am a number

O que fizemos foi simplesmente adicionar um método dinamicamente usando linguagem de programação, ou seja Metapgrogramação.

Por último, ficaremos com um idioma clássico do Ruby, que está presente em qualquer brincadeira que se presente de metaprogramação:

class << self; self; end

Esta pequena e bizarra linha, nos retornará uma classe singleton da classe que a utilizar, como demonstrado no exemplo abaixo:

class Screamer

  self.module_eval do
    define_method :scream do
      puts "I am a instance method!! AAAAAAH"
    end
  end

  (class << self; self; end).module_eval do
    define_method :scream do
      puts "I am a class method! AAAAAAH"
    end
  end

end

Screamer.scream         # => I am a class method! AAAAAAH
Screamer.new.scream     #I am a instance method!! AAAAAAH

Por enquanto é só. No futuro retomarei esse assunto com exemplos melhores para tornar tudo mais claro na prática.

Referências e links para se aprofundar no assunto:

Ruby Metaprogramming techniques por Ola Bini

Seeing Metaclasses Clearly por Whytheluckystiff

Understanding Ruby Singleton Classes por Peter Jones.