El viernes pasado di una charla de metaprogramación en Ruby en mi laburo. La misma duró algo así como una hora y media y me faltó mostrar algunas cosas (tenía que tardar una hora) y estuvo interesante (creo). Una hora y media a puro irb, sin slides y casi sin usar el pizarrón.
Acá pongo la planificación de la misma y algunos comentarios:
A continuación está la preparación de la charla:
Historia
Creado por Yukiro Matsumoto (AKA:Matz) en 1994 porque Perl no soportaba Kanji (encoding japonés). Se usó solo en Japón hasta que en el 2000 se publicó el libro: "Programming Ruby", primer libro de Ruby en inglés. Después lo agarró DHH e hizo Rails y se hizo famoso.
Comparaciones
Ruby tiene muchas de las cosas buenas de Perl, como soporte nativo con sintaxis propia para regex.
/\d+(\.\d+)?/ reconoce números (por ejemplo). Y como a Matz le gustaba Smalltalk, todo es un objeto.
También, como en Smalltalk, hay metaclases, las clases son objetos, todas las variables son referencias (no hay tipos primitivos) y se pueden pasar closures a los métodos.
Hands on
(las líneas que empiezan con >> las tipeo en el irb, las que empiezan con => son lo que escribe el irb solo, las que están en corchetes las pongo en un archivo)
En ruby podés hacer cuentas:
>> 1+1
=> 2
asignar a variables, usar strings:
>> var = "hola"
=> "hola"
>> var
=> "hola"
usar expresiones regulares para hacer cosas:
>> "5 mas 95 es 100".gsub( /\d+/, "numerito" )
=> "numerito mas numerito es numerito"
tambien hay una cosa que se llaman símbolos (que son como los símbolos de Lisp) y se escriben así:
>> :mi_simbolo
a muchos objectos (incluidos los simbolos) les puedo pedir que se muestren como strings:
>> :mi_simbolo.to_s
=> "mi_simbolo"
la diferencia entre los símbolos y los strings es que puede haber muchos strings con el
mismo texto pero solo un symbol con ese texto (object_id es un número único del objecto,
o sea que si dos objectos tienen el mismo número son el mismo objeto):
>> :mi_simbolo.object_id
=> 359538
>> :mi_simbolo.object_id
=> 359538
el object id es el mismo.
>> "mi_simbolo".object_id
=> 24163140
>> "mi_simbolo".object_id
=> 24160510
el object id es distinto.
También, como en Perl, hay interpolación de strings
>> "1 mas 1 es #{1+1}"
=> "1 mas 1 es 2"
Y como lo que devuelve es un string posta:
>> "1 mas 1 es #{1+1}".gsub( /\d+/, "numerito" )
=> "numerito mas numerito es numerito"
podés aplicarle todas las operaciones de string.
Arrays:
>> [1,2,3]
=> [1, 2, 3]
Hashes:
>> h = { :a => "aa", :b => "bb" }
=> {:b=>"bb", :a=>"aa"}
>> h[:a]
=> "aa"
Bueno ahora vamos a definir una clase. Edito en el gvim:
[
class A
def initialize( param )
puts "Inicializando A con #{param}"
@inst_var = param
end
def hace_algo( param )
"#{@inst_var} #{param}"
end
end
]
mostrar que no tengo que pasar self como en python
y uso la clase en el irb (después de cargarla):
>> a = A.new( "toto" )
Inicializando A con toto
=> #
esto guarda "toto" en la variable de instancia
>> a.hace_algo( "parametro" )
=> "toto parametro"
y acá lo muestra.
La herencia es herencia simple igual a otros lenguajes, así que no la muestro.
Otra cosa medianamente distintiva de Ruby es el uso de módulos como mixin:
Mostrar todos los métodos de instancia que tienen "algo" en su nombre:
>> A.instance_methods.select { |m| m.include? "algo" }
=> ["hace_algo"]
escribo en un archivo:
[
module M
def otro_algo( param )
"otro " + hace_algo( param )
end
end
]
lo cargo y después:
>> class A; include M; end
=> A
eso pone los métodos definidos en M en la clase A
>> A.instance_methods.select { |m| m.include? "algo" }
=> ["hace_algo", "otro_algo"]
Esto inclusive modifica a los métodos de las instancias vivas:
>> a.methods.select { |m| m.include? "algo" }
=> ["hace_algo", "otro_algo"]
Y los ejecuto para mostrar como llamar desde el módulo a la clase:
>> a.otro_algo( "aaaaaaaaaaa" )
=> "otro inicial aaaaaaaaaaa"
Como acaban de ver cuando hice el include, las clases de ruby son abiertas. Alguien se acuerda de VB? Algo que siempre me gustó es que en vez de escribir "self" o "this" usamos "me".
Abro un archivo y escribo:
[
class Object
def me
self
end
end
]
Lo cargo (load ....) y lo uso:
>> me
=> main
>> me.class
=> Object
También lo puedo usar dentro de otras clases:
>> class A; def klass; me.class; end; end
=> nil
>> a.klass
=> A
Otro feature interesante es el de los bloques de código (AKA: closures)
Ya vimos un ejemplo del uso cuando miramos los nombres de los métodos definidos en A y a.
Mirando un toque más en detalle:
>> [1,2,3,4,5].each { |n| puts "Numero #{n}" }
Numero 1
Numero 2
Numero 3
Numero 4
Numero 5
=> [1, 2, 3, 4, 5]
También puedo hacer mis propios métodos que reciban bloques de código, recordando que las clases son abiertas, modifico Integer para iterar. (Acá nos desviamos un toque de la planificación y mostramos también como usar parámetros del método definido dentro del closure. Dejo la planificación original):
>> class Integer; def veces( &block ); (1..self).each { |n| block[n] }; me; end; end
=> nil
>> 3.veces{ |n| puts n }
1
2
3
=> 3
Los métodos se pueden definir en clases y en objetos, por ejemplo:
>> b = [1,2,3,4,5,6]
=> [1, 2, 3, 4, 5, 6]
>> def b.sarasa(toto); "sarasa #{toto}";end
=> nil
>> b.sarasa
ArgumentError: wrong number of arguments (0 for 1)
from (irb):71:in `sarasa'
from (irb):71
from :0
(ups, me olvidé de pasarle el parámetro).
>> b.sarasa( "aaaaaaaaaaaa" )
=> "sarasa aaaaaaaaaaaa"
En ruby puedo definir properties "tipo Delphi" (o C#). Para esto, hay varios métodos
definidos en la clase Module. Acá muestro uno:
>> class A; attr_accessor :sarasa; end
=> nil
>> a.sarasa = "SARASASASA"
=> "SARASASASA"
>> a.sarasa
=> "SARASASASA"
Ahora bien, attr_accessor es un método del lenguaje (no una palabra reservada) así que voy
a implementarlo de nuevo.
[
class Module
def my_attr_accessor( symbol )
instance_var = "@#{symbol}"
define_method( symbol ) { instance_variable_get instance_var }
define_method( symbol.to_s + "=" ) { |value|
instance_variable_set instance_var, value }
end
end
]
Hago load y lo uso:
>> class A; my_attr_accessor :toto; end
=> #
>> a.toto = 5
=> 5
>> a.toto
=> 5
Salvo por cuestiones de performance my_attr_accessor (y que le falta funcionalidad) es equivalente
al original. Toda la funcionalidad se puede implementar, pero tardaría más y no tengo tiempo ni ganas.
También se pueden hacer métodos de clase que son solo para una clase específica, usando la metaclase.
>> class A; def self.klass_method; "klass_method";end;end
=> nil
>> class A; klass_method; end
=> "klass_method"
>> class B; klass_method; end
NameError: undefined local variable or method `klass_method' for B:Class
from (irb):75
from :0
Notar que lo que hice es definir un método para una sola instancia de la clase Class.
>> class C < A; klass_method; end
=> "klass_method"
También vale para las clases que heredan de la misma. Esto es lo que hacen en Rails para poder hacer:
class Entity < ActiveRecord::Base
has_many :other_entity
end
Como en Smalltalk, se puede hacer override de method_missing para hacer proxies dinámicos y esas cosas (en la charla tuve que saltear esta parte porque venía atrasado de tiempo, así que se perdieron mi DSL de diálogos de pelis porno):
[
class A
def method_missing( method_id, *args, &block )
action = "action_#{method_id}"
(respond_to? action) ? send(action) : super( method_id,*args, &block )
end
def action_a
puts "AAAAAAhhhh"
end
def action_o
puts "OOooohhhh"
end
end
]
Y lo uso:
>> load "bdlv.rb"
=> true
>> a.a
AAAAAAhhhh
=> nil
>> a.o
OOooohhhh
=> nil
>> a.metodo_que_no_existe
NoMethodError: undefined method `metodo_que_no_existe' for #
from ./bdlv.rb:17:in `method_missing'
from (irb):107
from :0
Por último, mostré markaby:
>> require 'markaby'
=> true
>> mab = Markaby::Builder.new
=> #<Markaby::Builder:0x2ef2160 @auto_validation=true, @assigns={}, @output_meta
_tag=true, @builder=<inspect/>, @indent=0, @streams=[["<inspect", "/", ">"]], @h
elpers=nil, @tagset=Markaby::XHTMLTransitional, @output_xml_instruction=true, @o
utput_helpers=true, @elements={}>
>> mab.html do
?> head { title "Core se la banca" }
>> body do
?> h1 "Productos de Core"
>> ul do
?> li "Sarasa $500000000"
>> li "Sarasa2 $100000000"
>> li "Consulting priceless"
>> end
>> end
>> end
=> "<html><head><meta content=\"text/html; charset=utf-8\" http-equiv=\"Content-
Type\"/><title>Core se la banca</title></head><body><h1>Productos de Core</h1><u
l><li>Sarasa $500000000</li><li>Sarasa2 $100000000\n</li><li>Consulti
ng priceless</li></ul></body></html>"
Notar que es código ruby! Por ejemplo, puedo iterar:
>> mab = Markaby::Builder.new
=> #<Markaby::Builder:0x2ecec9c @auto_validation=true, @assigns={}, @output_meta
_tag=true, @builder=<inspect/>, @indent=0, @streams=[["<inspect", "/", ">"]], @h
elpers=nil, @tagset=Markaby::XHTMLTransitional, @output_xml_instruction=true, @o
utput_helpers=true, @elements={}>
>> mab.html {
?> body {
?> ul {
?> [ "Sarasa $500000", "Sarasa2 $100000", "Consulting priceless" ].each do
?> |item| li item
>> end
>> }
>> }
>> }
=> "<html><body><ul><li>Sarasa $500000</li><li>Sarasa2 $100000</li><li>Co
nsulting priceless</li></ul></body></html>"
Por supuesto, este html es básico pero esto es CÓDIGO. Por ejemplo, haciendo un form:
>> mab.html { body { form( :target => "http://sarasa" ) { input( :type => :submit ) } } }
=> "<html><body><form target="http://sarasa"><input type="submit"/></form></body></html>"
También mostré como yapa el ejemplo del tutorial de rake.
Y me faltó el ejemplo de como manipular Excel, pero lo dejo acá:
require 'win32ole'
# -4100 is the value for the Excel constant xl3DColumn.
ChartTypeVal = -4100;
# Creates OLE object to Excel
excel = WIN32OLE.new("excel.application")
# Create and rotate the chart
excel['Visible'] = TRUE;
workbook = excel.Workbooks.Add();
excel.Range("a1")['Value'] = 3;
excel.Range("a2")['Value'] = 2;
excel.Range("a3")['Value'] = 1;
excel.Range("a1:a3").Select();
excelchart = workbook.Charts.Add();
excelchart['Type'] = ChartTypeVal;
30.step(180, 10) do |rot|
excelchart['Rotation'] = rot
end
excelchart2 = workbook.Charts.Add();
excelchart3 = workbook.Charts.Add();
charts = workbook.Charts
charts.each { |i| puts i }
excel.ActiveWorkbook.Close(0);
excel.Quit();
