sábado, 29 de mayo de 2010

Definicion de clases y metodos en un eval

Una de las miles de cualidades que tiene ruby como lenguaje dinamico es la ejecucion de codigo ruby contenido en un string mediante el uso de la funcion eval.
Asi se pueden hacer cosas bastante interesantes ejecutando codigo ingresado dinamicamente ^_^
No obstante es necesario conocer como sortear determinados obstaculos en la ejecucion de codigo dinamico


class Runner
def run(code)
eval(code)
end
end

runner = Runner.new

# ¡¡FAIL!! :(, no se puede definir classes desde adentro de un metodo (Runner#run)
runner.run("
class X
def foo
print \"hello world\n\"
end
end

x = X.new
x.foo
")



Lo que se intento hacer en el ejemplo anterior, para el interprete es equivalente a:


class Runner
def run(code)
# いけない!!!
# en ruby no esta permitido definir clases adentro de metodos
# (aunque si permite hacer otras cosas locas XD )
class X
def foo
print \"hello world\n\"
end
end

x = X.new
x.foo
end
end


Para poder hacerlo correctamente hay que pasarle un segundo parametro a eval que es el "binding", un binding representa el contexto en ruby de donde se llama el binding, que incluye las variables locales, etc... mejor verlo en el ejemplo que explicarlo:


class Runner

class << self
attr_accessor :runner_binding
end

def run(code)
# se especifica un binding al eval para definir el contexto
# en el que se ejecuta el codigo
eval(code, Runner.runner_binding)
end
end

# se copia el binding del contexto actual (fuera de cualquier clase o metodo)
Runner.runner_binding = binding

runner = Runner.new

# se puede definir clases en el codigo pasado a eval, porque el binding
# esta afuera de cualquier declaracion de clase o metodo y el eval se
# llama con ese binding
runner.run("
class X
def foo
print \"hello world\n\"
end
end

x = X.new
x.foo
")




Que para el interprete es lo mismo que reemplazar el codigo en donde se llama a binding en lugar de en donde se llama a eval:


class Runner

class << self
attr_accessor :runner_binding
end

def run(code)
# se especifica un binding al eval para definir el contexto
# en el que se ejecuta el codigo
eval(code, Runner.runner_binding)
end
end

# よろしい
# Runner.runner_binding = binding
class X
def foo
print \"hello world\n\"
end
end

x = X.new
x.foo




Y ya que estamos, les cuento que otra cosa tiene el eval para hacer


def bar
1/0 # ZeroDivisionError
end

def foo(code) # ¿porque siempre foo?
eval(code)
end

foo("bar") #


Resultado:


test.rb:6:in `foo': test.rb:2:in `/': divided by 0 (ZeroDivisionError)
from test.rb:2:in `bar'
from (eval):1:in `foo'
from test.rb:9:in `eval'
from test.rb:6:in `foo'
from test.rb:9



Mejor, pasarle unos argumentos adicionales a eval especificando el "archivo" y el numero de linea de donde viene el codigo evaluado


def bar
1/0 # ZeroDivisionError
end

def foo(code) # ¿porque siempre foo?
eval(code, binding, "foo_eval.rb", 1)
end

foo("bar") #


Resultado:


test.rb:2:in `/': divided by 0 (ZeroDivisionError)
from test.rb:2:in `bar'
from foo_eval.rb:1:in `foo'
from test.rb:6:in `foo'
from test.rb:9


Ahora se puede ver mejor en el backtrace de donde viene el codigo, con esto mejorada la trazabilidad cuando se usa eval.

jueves, 6 de mayo de 2010

¡Cuidado! Pizza Radioctiva

Ficha tecnica:

Radiancia: 5.9 Kilopluts a temp. ambiente
Queso: 1.8 Kilogramos
Tomate: 4.5 Terawatts

Aceitunotones nominal: 2 (ya disipados)
Vida Media: 9 minutos desde la salida del horno

miércoles, 24 de marzo de 2010

Como escribir una extension ruby en C en 5 minutos

Lo siguiente toma lugar entre las 15:51 pm y las 15:56 pm

Para crear una extension en ruby lo primero que hay que hacer, es crear el "extconf.rb", basicamente tiene que tener el siguiente contenido:


# extconf.rb
require 'mkmf'

dir_config("exttest")

create_makefile("exttest")


Posteriormente, hay que crear el archivo del codigo fuente en C de la extension, que minimamente tiene que haber uno, en este caso creamos uno de prueba, bastante resumido, el cual crea un modulo ruby y le define dos metodos, ambos implementados en C:


// exttest.c

#include "ruby.h"

static VALUE foo(VALUE self) {
printf("Foo invoqued\n");
return Qnil;
}

static VALUE sum(VALUE self, VALUE a, VALUE b) {
return INT2NUM( NUM2INT(a) + NUM2INT(b) );
}


void
Init_exttest()
{
VALUE rb_exttest = rb_define_module("Exttest"); // definir el modulo

rb_define_singleton_method(rb_exttest, // en que modulo
"foo", // nombre del metodo
foo, // puntero a la implementacion C del metodo
0 // cantidad de argumentos del metodo
);

rb_define_singleton_method(rb_exttest, // en que modulo
"sum", // nombre del metodo
sum, // puntero a la implementacion C del metodo
2 // cantidad de argumentos del metodo
);

}




Para generar el makefile (solo hay que hacer esto una vez), se ejecuta el script extconf.rb:

ruby extconf.rb


Para construir la extension, se debe lanzar el siguiente comando:


make


Eso genera, entre otros archivos intermedios, extconf.so, el cual contiene la extension misma compilada a codigo nativo de la plataforma donde estan corriendo todo, para instalarla en el sistema, hay que correr (como root):


make install


Para usar la extension:



# test.rb
require 'rubygems'
require 'exttest'

Exttest.foo # el metodo foo definido en exttest.c!!
print Exttest.sum(4,9),"\n" # el metodo sum definido en exttest.c!!



Posteriormente, se pueden hacer cosas mas interesantes como definir clases, clases anidadas en modulos, metodos, etc...
Para la proxima voy a explicar como encapsular la extension como gem y distribuirla

links:

* http://onlamp.com/pub/a/onlamp/2004/11/18/extending_ruby.html: Fuente que inspiro este articulo y ejemplo practico de como wrappear la libreria GenX como libreria ruby GenX4r
* http://rhg.rubyforge.org/chapter04.html: Tutorial que muestra como definir clases y modulos
* http://ruby-doc.org/doxygen/1.8.4/group__ruby__interp.html: Documentacion completa de funciones C para definir extensiones de ruby incluyendo funciones de conversion de datos

miércoles, 10 de marzo de 2010

En github solo se tarda 60 SEGUNDOS

Esta mañana, entre a la internet con la idea de migrar un proyecto que tenia en googlecode (con svn) a git (y el mas conocido repositorio gratuito en internet de git es github)
El hecho de tener que migrar commits de svn a git ademas de la registracion, setup del repo git y demas cosas me hacian imaginar q seria una experiencia de trabajo.
Pero me soprendi: no solo registrarse y crear el repositorio fueron tres simples clicks, sino que tambien hay literalmente un boton "migrar SVN a GIT" en el cual solo te pedia la url del servidor svn... tras la operatoria (que encima fue rapida), pude ver mis commits convertidos a git.
Asi que el que este entusiasmado con git, sabe que no solo puede registrarse facilmente a un repositorio git gratuito sino que puede tambien migrar cualquier repositorio de svn para no perder la valiosa informacion de los commits en la mudanza.

Enlaces:

GitHub:
http://github.com/

GoogleCode ( Aun asi esta bueno si quieren usar un repo svn y el issue-tracker les puede gustar :) ):
http://code.google.com/

miércoles, 24 de febrero de 2010

Analisis de mergeo en git

Cada vez que se mergea una rama en otra, es necesario conocer que modificaciones se estarian introduciendo concretamente en la rama de destino antes de proceder al mergeo mismo.

El comando git-merge-base permite saber cual es el "common parent" de dos commits dados, es el "merge-base" el que define que segemento de cambios se incluiran al hacer el mergeo.

Supongamos que se quiere mergear a la rama xxxxx, los cambios de la rama yyyyy, pero antes se desea conocer que cambios se incluiran


# se cambia la rama de trabajo a yyyyy
$ git checkout yyyyy

# se busca el "merge base
$ git merge-base HEAD xxxxx
123456789abcdef

# se analizan los cambios que se incluiran viendo el segemento de cambios desde el merge-base
# hasta el ultimo commit de xxxxx
$ git log 123456789abcdef..xxxxx
( aparece una enumeracion de los commits que se van a incluir si se procede al mergeo)

# o tambien, se podria
$ git log $(git merge-base HEAD xxxxx)..xxxxx
( aparece la misma salida que del comando anterior)

# si se aceptan los commits vistos en el log, se procede al mergeo
git merge xxxxx


NOTA: Ademas de usar estos practicos comandos ayuda bastante mantener una nomeclatura y una gestion ordenada de las ramas que permitan tener en claro cuales son los "merge-base" de los mergeo que se ejecutaran.

miércoles, 9 de diciembre de 2009

Recuperar commits "perdidos" en git

Cada tanto puede pasar que de checkout en checkout, nos encontramos con:

"¡oh no!, todos los commits que hice hoy no estan en la rama, incluso nisiquiera se donde estan"

Pareciera que todo el trabajo del dia quedo "perdido", pero no es asi, si se commiteo, esos commits estan en alguna parte... quiza no apuntados por ninguna referencia, pero estan.

Una de las maneras mas practicas de encontrarlo es usando el comando


git reflog


Que da por salida un registro de las operaciones que se hicieron, algo como esto:


8705300... HEAD@{0}: commit: aplicado metodo para desactivar los metodos privado
104683b... HEAD@{1}: commit: corregida restauracion de constantes
0a714ab... HEAD@{2}: commit: corregido error
f47b0e6... HEAD@{3}: commit: implementado metodo para activar y desactivar privi
7760e03... HEAD@{4}: commit: definido metodo permit, para definir muy facilmente
2936507... HEAD@{5}: commit: renombrado metodo para preguntar el permiso para ej
93757af... HEAD@{6}: commit: agregados enable y disable privileges con prints
4a2e9c3... HEAD@{7}: commit: agregado metodos para crear bloques unprivileged y
f19eb66... HEAD@{8}: commit: completado holder de manera que puede tener el codi
abc82d0... HEAD@{9}: commit: separado metodo create_holder
5185142... HEAD@{10}: commit (initial): primer commit


Incluye los "SHA1" de los commits hechos recientemente, de los cuales se pueden tomar los cambios y enviarlos al lugar correspondiente con git merge, crear branches o lo que sea necesario hacer.

domingo, 29 de noviembre de 2009

Sandbox de codigo ruby

La semana pasada empece el desarrollo de una libreria de ruby que permita crear "sandbox" de codigo ruby

Un sandbox (traducido literalmente del ingles como "caja de arena") es un entorno "protegido" que permite ejecutar programas de una manera en la que no es posible que estos programas afecten a lo que esta "afuera" del sandbox (Por ej: ejecutar un programa de manera que no pueda tener acceso al sistema de archivos de la computadora en la que se esta ejecutando)
Enlace
Para el caso particular de ruby, cuando se da, por ejemplo, el caso del desarrollo de una plataforma que ejecuta dinamicamente codigo enviado por muchos usuarios... es esperable que este codigo no pueda acceder al sistema de archivos o a la bases de datos de la aplicacion (el caso de una aplicacion Rails). En ese caso un "sandbox" que encierre al codigo en su ejecucion restringiria la ejecucion de codigo no deseado.

En lo que se ve a simple vista en la web, no hay mucho desarrollo al respecto... y lo que hay pareciera ser plugins algo mas especificos de rails como acts_as_runnable_code. Es por eso que comence el proyecto arena-ruby-sandbox, que define la posibilidad de ejecutar el codigo asi:




require "sandbox"

class X
def foo(a)
print "foo(#{a})\n"

# estoy afuera del sandbox, por lo tanto puedo
# hacer cosas "privilegiadas" como crear archivos
# cosa que no puede hacerse desde adentro del sandbox
File.open("foo.txt") do |f|
f.write "foo(#{a})\n"
end

a+5
end

def foo_no_invocable
print "foo_no_invocable\n"
end
end

# instanciar el sandbox
s = Sandbox::Sandbox.new

x = X.new

s.serivice_provider = x
# indica que el metodo foo se puede ejecutar desde adentro del sandbox
s.permit :foo

print s.run("2+2") # => 4

print s.run("foo(2)") # => 7 (y escribe el archivo foo.txt con "foo(2)" )

print s.run("foo_no_invocable") # => NoMethodError (nunca se especifico que foo_no_invocable se podia invocar)

s.run("
File.open('foo.txt') do |f|
f.write \"foo\n\"
end
") # => NameError: uninitialized constant File
# ( la clase File no existe adentro del sandbox
# no se puede acceder al filesystem desde el sandbox
links

http://arena-ruby-sandbox.googlecode.com