Bosque Viejo » ruby http://bosqueviejo.net Sitio web sobre programación, software libre, redes, servidores, ofimática... y todo lo relacionado con la informática que nos rodea Tue, 08 May 2012 14:40:56 +0000 es hourly 1 http://wordpress.org/?v=3.3.2 Juggernaut: invirtiendo el paradigma cliente/servidor http://bosqueviejo.net/2012/05/08/juggernaut-invirtiendo-el-paradigma-clienteservidor/ http://bosqueviejo.net/2012/05/08/juggernaut-invirtiendo-el-paradigma-clienteservidor/#comments Tue, 08 May 2012 14:40:56 +0000 bombadil http://bosqueviejo.net/?p=1371 Juggernaut, además de ser un personaje del universo Marvel, es un servidor escrito en Node.JS, que permite su integración con Ruby on Rails para realizar el intercambio de mensajes en dirección del servidor hacia el navegador.

Este esquema permite al servidor poder enviar mensajes al navegador en cualquier momento, de modo que se mantiene una actualización mucho más precisa que con refrescos esporádicos del navegador web hacia el servidor.

¿Cómo funciona?

Juggernaut, para conseguir esto se basa en el uso de un código en Flash que le permite abrir un socket y mantener la comunicación con el servidor de forma constante. En la parte del cliente, por lo tanto, está el navegador que realiza las peticiones al código de Rails como siempre y, además, el código Flash que abre la comunicación con el servidor de Juggernaut, que le va enviando código en JavaScript que ejecuta para realizar acciones concretas.

En la parte del servidor tenemos también dos elementos bien diferenciados, por un lado tenemos al servidor de Juggernaut ejecutándose en el puerto 5001 (por defecto) y el servidor de Rails ejecutándose en otro puerto (por defecto en desarrollo suele ser el 3000). La comunicación con el servidor de Rails es como siempre en protocolo HTTP, mientras que el intercambio de información a través del interfaz de Juggernaut se sucede en formato JSON, enviando información específica a ejecutar en el navegador.

Instalación

La verdad es que la instalación no queda nada clara, por lo que voy a explicar el cómo se instala el sistema para tenerlo funcionando en poco tiempo. En principio, necesitamos ejecutar lo siguiente:

gem install json
gem install eventmachine
gem install juggernaut
gem install maccman-juggernaut -s http://gems.github.com

Tenemos que crear un proyecto Rails. En principio, tendrá que ser una versión anterior a la 3.2, ya que en esa versión se ha eliminado el uso de plugins en favor de las gemas, por lo que, creamos nuestro proyecto Rails y ejecutamos:

ruby script/plugin install git://github.com/maccman/juggernaut_plugin.git

Ahora toca lanzar la parte servidora de Juggernaut, para eso, vamos a generar un fichero de configuración, el sistema nos puede generar uno automáticamente de la siguiente forma:

juggernaut -g juggernaut.yml

Con esto ya tenemos instalado todo el sistema de Juggernaut, y lo básico para poder integrarlo dentro de nuestro proyecto Rails.

Implementando Juggernaut en Rails

Introducir Juggernaut en Rails es tan sencillo como crear un nuevo controlador, por ejemplo uno llamado Chat, y escribir el siguiente código en el fichero chat_controller.rb:

class ChatController < ApplicationController
  def index
  end
 
  def send_data
    render :juggernaut do |page|
        page.insert_html :top, 'chat_data', "<li><strong>#{params['id']}</strong>: #{h params['chat_input']}</li>"
    end
    render :nothing => true
  end
 
end

En este código tenemos dos entradas, una es el index que lo emplearemos para entrar en la página inicial, y otra es la parte de envío de datos, a la que llamaremos mediante AJAX. El formulario lo montamos de la siguiente forma en el fichero index.html.erb:

<html>
<head>
    <title>Chat</title>
    <%= javascript_include_tag :defaults, :juggernaut %>
    <%= juggernaut(:client_id => params[:id]) %>
</head>
<body>
    <%= form_remote_tag(
          :url => { :action => :send_data },
          :complete => "$('chat_input').value = ''" ) %>
    <%= text_field_tag( 'chat_input', '', { :size => 20, :id => 'chat_input'} ) %>
    <%= hidden_field_tag( 'id', params[:id] ) %>
    <%= submit_tag "Add" %>
    </form>
    <ul id="chat_data" style="list-style:none">
    </ul>
</body>
</html>

Lanzando la aplicación

Lanzamos Rails (ya sea con mongrel, thin o cualquier otro servidor) y Juggernaut. El lanzamiento de Juggernaut lo podemos hacer de la siguiente forma:

juggernaut -c juggernaut.yml

Ahora vamos al navegador, abrimos dos navegadores:

Si vamos escribiendo en una ventana, veremos como van apareciendo los textos en ambas, algo como esto:

Con lo que comprobamos que el sistema funciona correctamente.

Algunas pegas

Como hemos visto desde el principio, la comunicación del navegador se realiza a través de un puerto que no es el 80, típico del protocolo HTTP, y que tampoco es protocolo HTTP lo que transita por ese puerto, por lo que, en instalaciones con acceso a Internet restringido, es posible que este sistema no funcione correctamente.

Además, se suma el problema de que el puerto 5001 debe de mantenerse abierto hacia Internet, si no configuramos con suficiente seguridad, a través del fichero juggernaut.yml el sistema, podemos encontrarnos un verdadero agujero de seguridad… ya depende de para qué usemos Juggernaut, pero teniendo en cuenta de que ejecuta código JavaScript en el cliente, podría ser algo nocivo.

Conclusiones

Esta aproximación al sistema de Juggernaut ha sido bastante interesante para descubrir una forma de realizar este tipo de comunicaciones entre cliente y servidor de forma inversa, es decir, que el servidor pueda enviar información al cliente sin que el cliente la solicite. No obstante, los navegadores actuales implementan un sistema denominado websocket que tenderá a sustituir estos mecanismos artesanos de una forma más estándar y frameworks como ChicagoBoss ya lo implementan de forma nativa. El futuro nos mostrará los caminos que se van tomando, de momento, Juggernaut es una muy buena solución para todos los navegadores web actuales.

]]> http://bosqueviejo.net/2012/05/08/juggernaut-invirtiendo-el-paradigma-clienteservidor/feed/ 0 Las gemas de Ruby http://bosqueviejo.net/2012/01/02/las-gemas-de-ruby/ http://bosqueviejo.net/2012/01/02/las-gemas-de-ruby/#comments Mon, 02 Jan 2012 17:03:31 +0000 bombadil http://bosqueviejo.net/?p=1165 Tengo a Ruby un poco abandonado, por lo que me he decidido a escribir un poco acerca de él, al igual que hice con Python, para detallar un poco cómo son los paquetes de código (o librerías) de Ruby: las gemas.

Las gemas de Ruby son paquetes de librerías para Ruby que se instalan en el sistema y quedan listas para ser usadas, con un simple require o con mecanismos que aporta el propio sistema de gemas para Ruby.

El gestor de gemas: rubygems

En distribuciones de GNU/Linux, e instalaciones automáticas para Windows, se nos habilita un comando, generalmente, que nos permite agregar librerías y código de un repositorio muy extenso de código listo para usar. Esto es conocido como el gestor de gemas, rubygems, o simplemente gem.

El gestor de gemas es un comando que nos permite listar las gemas instaladas, buscar gemas remotas o localmente (de las instaladas), instalar, actualizar y eliminar gemas. Se puede saber si está instalado simplemente ejecutando:

gem --version

La última versión a día de hoy es la 1.8.12, actualizar el sistema de gemas es tan simple como ejecutar:

gem update --system

Instalar una gema

Por ejemplo, si queremos usar el código siguiente:

require "rubygems";
require "json";
 
puts [ "hola a todos", 12, "C/Sin nombre, 25" ].to_json

Tendremos que instalar previamente la gema json. Para instalarla, solo tenemos que ejecutar el siguiente comando:

$ sudo gem install json
[sudo] password for marubio: 
Building native extensions.  This could take a while...
Successfully installed json-1.6.4
1 gem installed
Installing ri documentation for json-1.6.4...
Installing RDoc documentation for json-1.6.4...

Como se puede apreciar, se instala la gema y se genera la documentación para ri y rdoc. La generación de la documentación es bastante lenta y si tenemos que instalar muchas gemas, puede ser algo tedioso. Se puede eliminar esta tarea agregando al comando de instalación: --no-ri --no-rdoc

Ahora, cuando listemos los paquetes instalados podremos ver:

$ sudo gem list
 
*** LOCAL GEMS ***
 
json (1.6.4)

Nos indica la versión, ya que podríamos tener varias versiones instaladas y conviviendo, y desde el código emplear la que requiramos específicamente. Si queremos instalar una versión específica de un paquete, podemos hacerlo agregando la opción, por ejemplo: --v=1.6.1

Buscando una gema

Si queremos buscar una gema específica del directorio de gemas, podemos hacerlo a través de la propia página web: RubyGems; o a través del comando:

$ gem search -r jsonn
 
*** REMOTE GEMS ***
 
active_record_serialize_json (0.1.2)
activejson (0.1.2)
activeresource_json_patch (0.0.1)
assert_json (0.1.1)
capcode-render-json (0.2.0)
capybara-json (0.1.1)
colorful_json (0.9.1)
csv2json (0.2.0)
cucumber-json (0.0.2)
dm-json-search (0.0.3)
[...]

La base de datos de gemas tiene la friolera de más de 32 mil gemas, por lo que, no es de extrañar que ante algo trivial (como JSON) puedan aparecer cientos de gemas. A la hora de buscar deberemos de ser más precisos con los términos a elegir.

Conclusiones

Ha sido una introducción muy ligera a este entorno de gestión de paquetes de Ruby, lo sé, pero al menos complementa un poco la entrada de hace algunos meses sobre Bundler y da un poco de información sobre los comandos más usuales a la hora de instalar una librería en Ruby, ya sea para código scripting o para Rails.

]]> http://bosqueviejo.net/2012/01/02/las-gemas-de-ruby/feed/ 0 RSS: leyéndolos desde PHP y Rails http://bosqueviejo.net/2011/11/14/rss-leyendolos-desde-php-y-rails/ http://bosqueviejo.net/2011/11/14/rss-leyendolos-desde-php-y-rails/#comments Mon, 14 Nov 2011 10:26:04 +0000 bombadil http://bosqueviejo.net/?p=1057 Hace un tiempo hice un lector de RSS para poner noticias en una web, en Ruby on Rails, y me gustó la simpleza con la que se parsean los códigos y se pueden presentar las noticias, sin mucho esfuerzo, y apenas líneas de código. Unos días más tarde, me tocó hacerlo también en PHP… e aquí un ejemplo de simpleza de un framework, frente a un lenguaje.

Versión PHP

Empezaremos con la complicada. Este código se encarga de descargar el código del RSS y deserializar el XML en un array, para poder tratarlo a posteriori. El tratamiento lo haré en plan cutre, ya que me intentaré, sobretodo, basar en el proceso de descarga y deserialización.

Para esto, se requiere de una librería que no suele venir con PHP, pero sí está en PEAR, con lo que, se puede instalar fácilmente ejecutando la siguiente línea de comandos:

pear install XML_Serializer

Con esto, el código, en plan simple, sería el siguiente:

<?php
 
 
include 'XML/Unserializer.php';
 
function xml_to_array( $data ) {
    $options = array(
        "addDecl"            => true,
        "encoding"           => "utf-8",
        "mode"               => XML_SERIALIZER_MODE_SIMPLEXML,
        "indent"             => "    ",
        "linebreak"          => "\n",
        "scalarAsAttributes" => true,
        "attributesArray"    => '_a',
        "contentName"        => '_c',
        "rootName"           => 'rss'
    );
 
    $unserializer = new XML_Unserializer($options);
    $unserializer->unserialize($data);
    $doc = $unserializer->getUnserializedData();
 
    return $doc;
}
 
$data = xml_to_array(file_get_contents('http://www.debian.org/News/news'));
?>
<html>
<body>
    <? foreach ($data["item"] as $noticia) { ?>
    <h1><a href="<?=$noticia["link"]?>"><?=$noticia["title"]?></a></h1>
    <p class="date"><?=date("d/m/Y H:i", strtotime($noticia["dc:date"]))?></p>
    <p class="desc"><?=$noticia['description']?></p>
    <? } ?>
</body>
</html>

No pinta mal, conseguimos lo que nos proponemos sin tener muchas complicaciones.

Ahora la versión bonita

En Rails las cosas siempre tienden a ser más simples, o al menos mucho más cortas, muestra de ello, es la versión del código anterior en versión Rails. Este sería:

  def noticias
    require 'rss/1.0'
    require 'rss/2.0'
    require 'open-uri'
 
    source = "http://www.debian.org/News/news"
    content = ""
    open(source) do |s| content = s.read end
    @rss = RSS::Parser.parse(content, false)
  end

Aunque he puesto los require dentro de la función, realmente podrían ponerse en otro sitio (como en environment.rb) y no requieren de la instalación de ninguna gema extra. En la vista sería tan solo usar el código de la siguiente forma:

<% @rss.items.each do |i| %>
    <h1><%= link_to i.title, i.link %></h1>
    <p class="date"><%=i.date.strftime("%d/%m/%Y %H:%M")%></p>
    <p class="desc"><%=simple_format(i.description)%></p>
<% end %>

Los helpers ayudan bastante en la creación del código, haciendo que los enlaces se hagan de forma simple, así como el formateado de la fecha, y el parseo del texto para HTML.

Conclusiones

He estado revisando el repositorio PEAR, donde he podido ver que había un par de paquetes de RSS, uno de ellos sin mantenimiento ya (XML_RSS), y el resto de blogs que he visitado lo hacen como he mencionado, por lo que, obliga a conocer los distintos formatos de los que se van a rescatar noticias, ya sean Atom, RSS (la versión que corresponda), etc. Me parece que en este sentido Rails ha demostrado ser más serio o aplicado.

]]> http://bosqueviejo.net/2011/11/14/rss-leyendolos-desde-php-y-rails/feed/ 0 Rails 3.1: mejorando las vistas http://bosqueviejo.net/2011/10/17/rails-3-1-mejorando-las-vistas/ http://bosqueviejo.net/2011/10/17/rails-3-1-mejorando-las-vistas/#comments Mon, 17 Oct 2011 20:59:11 +0000 bombadil http://bosqueviejo.net/?p=992 Puf, no sé ni por donde comenzar, han sido tantas cosas las que he visto en el cambio de la versión de Rails 3.0 a esta nueva liberación… pero no solo por las mejoras que conlleva o tiene esta nueva liberación, sino más bien por esa cantidad de elementos que se anexan y que no conocía… ya me vale :-P

En principio, podemos decir que una de las grandes mejoras (para muchos), es que ya no trae por defecto prototype, sino que se han decantado por jQuery. No obstante, como todavía hay gente que considera el uso de prototype para sus desarrollos, pues lo que han hecho es que por defecto se instala jQuery, pero se puede indicar a través de una opción que se instale en su lugar prototype. Esto es gracias a que han extraído estas librerías a gemas independientes: prototype-rails y jquery-rails.

En segundo lugar, y siguiendo con el tema de la parte cliente, han integrado unos asset pipelines, que facilitan la generación de código CSS y JavaScript a través de elementos como CoffeeScript, Sass, Less… y todos ellos a través de Sprockets.

Con el uso de Ruby 1.9.2 (o Rubinius o JRuby en modo 1.9) y un servidor como Unicorn, podemos emplear otra de las nuevas características: HTTP Streaming. Esta característica permite la descarga de las imágenes, elementos CSS y JS, mientras se genera la vista del HTML.

Otra de las ventajas que sobresale en esta versión es el Identity Map. Esta característica de Rails, más en concreto de ActiveRecord, hace que cuando un objeto se rescata de la base de datos, si se solicita de nuevo el mismo objeto, no se solicite de nuevo, sino que se tome el que ya está recogido y en memoria. Esto lo hace solo para los objetos que se instancian en la petición en curso y que son eliminados de la caché cuando la petición finaliza.

El resto ya son mejoras menores, como:

  • El uso de JSON en lugar de XML para el scaffold.
  • La creación de helpers para la autenticación de HTTP Basic y Digest.
  • El uso del método change en lugar de up y down en las migraciones, generando la marcha atrás el sistema de forma automática.
  • El uso de up y down como métodos de objeto y no de clase.
  • La posibilidad de crear serializadores de forma fácil (los de XML y JSON vienen por defecto).
  • y muchas más…

Para más información, puedes leer la ficha de liberación completa (en inglés).

Realmente, Rails está avanzando mucho y desde que comencé a usarlo, hará ya tres años, lo he visto agregar cada vez más nueva tecnología y elementos que me han ayudado a aprender mucho sobre el desarrollo profesional de entornos web. Así da gusto.

]]> http://bosqueviejo.net/2011/10/17/rails-3-1-mejorando-las-vistas/feed/ 0 Celluloid: Concurrencia en Ruby http://bosqueviejo.net/2011/10/06/celluloid-concurrencia-en-ruby/ http://bosqueviejo.net/2011/10/06/celluloid-concurrencia-en-ruby/#comments Thu, 06 Oct 2011 09:34:59 +0000 bombadil http://bosqueviejo.net/?p=947 Profundizando un poco en el Modelo Actor, en el que se basan lenguajes como Scala, Erlang o Reia, pero que también está disponible a través de frameworks para otros muchos lenguajes, como .NET, Java, Ruby, Python, etc.

Antes de comenzar, conviene que definamos un poco lo que es el modelo Actor. Según la wikipedia (versión inglesa) el modelo Actor es: un modelo matemático de computación concurrente que trata a los “actores” como las primitivas universales de la computación concurrente digital: en respuesta a mensajes que recibe, un actor puede tomar decisiones locales, crear más actores, enviar más mensajes y determinar cuando responder al siguiente mensaje recibido.

En este artículo me gustaría centrarme en Celluloid, un framework del modelo Actor para Ruby. Este framework nos permite tratar las instancias de los objetos como procesos autónomos, concurrentes, que atienden peticiones y mantienen su memoria, sin posibilidad de que pueda ser corrompida por dos mensajes simultáneos.

Un ejemplo de código de la propia página web, haciendo alusión al actor… vamos a castellanizarlo un poco:

class Bardem
  include Celluloid::Actor
 
  def initialize(nombre)
    @nombre = nombre
  end
 
  def pon_estado(estado)
    @estado = estado
  end
 
  def informa
    "#{@nombre} está #{@estado}"
  end
end

Para poder probarlo necesitamos de un entorno de pruebas que nos permita la ejecución de este código. Yo suelo usar rvm para poder instalar entornos de ruby de forma cómoda y poder probarlos, por lo que, solo hay que poner en consola:

rvm install 1.9.2-celluloid
rvm use 1.9.2-celluloid
gem install celluloid

IMPORTANTE: tener presente que Celluloid solo funciona en JRuby en modo 1.9, en Rubinius y en Ruby a partir de la versión 1.9.2, ya que las anteriores no tienen hilos de estado concurrente real.

En una consola de irb, se podría ejecutar lo siguiente:

ruby-1.9.2-p180 :001 > require "celluloid"
 => true
ruby-1.9.2-p180 :002 > require "./bardem.rb"
 => true
ruby-1.9.2-p180 :003 > javier = Bardem.spawn "Javier Bardem"
 => #
ruby-1.9.2-p180 :004 > javier.pon_estado "ha ganado!"
 => "ha ganado!"
ruby-1.9.2-p180 :005 > javier.informa
 => "Javier Bardem ha ganado!"
ruby-1.9.2-p180 :006 > javier.pon_estado! "gana asincronamente!"
 => nil
ruby-1.9.2-p180 :007 > javier.informa
 => "Javier Bardem gana asincronamente!"

Cuando se llama a spawn se crea el objeto dentro de su propio hilo. El paso de mensajes se realiza usando el manejador del actor específico (javier en este caso) y se puede pasar un mensaje de forma síncrona (esperando su resultado) o de forma asíncrona (con la exclamación) sin esperar a que retorne nada.

Supervisores

Los supervisores, son procesos que se encargan de supervisar que un proceso está levantado y funcionando (como los monitores), pudiendo reiniciarlos cada vez que se caen. Por ejemplo, podemos crear un supervisor del ejemplo anterior de la siguiente forma:

ruby-1.9.2-p180 :008 > penelope = Bardem.supervise "Javier Bardem"
 => #
ruby-1.9.2-p180 :009 > javier = penelope.actor
 => #

Así, creamos un supervisor (penelope) que supervisa al actor Javier Bardem. También podemos asignar un nombre al actor, de modo que:

ruby-1.9.2-p180 :011 > Bardem.supervise_as :javier, "Javier Bardem"
 => #
ruby-1.9.2-p180 :012 > javier = Celluloid::Actor[:javier]
 => #

De modo que el símbolo :javier se relacione con el proceso y pueda emplearse en lugar de Javier Bardem, cuando se realice una llamada.

Enlazado

Si se sucediese una excepción no manejada en cualquiera de los métodos del actor, ese actor se caería y moriría. Vamos a poner un ejemplo:

class JamesDean
  include Celluloid::Actor
  class CarInMyLaneError < StandardError; end
 
  def drive_little_bastard
    raise CarInMyLaneError, "that guy's gotta stop. he'll see us"
  end
end

Ahora, vamos a poner a James en el coche Little Bastard conduciendo y veamos que sucede:


ruby-1.9.2-p180 :001 > require "celluloid"
 => true
ruby-1.9.2-p180 :002 > require "./james_dean.rb"
 => true
ruby-1.9.2-p180 :003 > james = JamesDean.spawn
 => #
ruby-1.9.2-p180 :004 > james.drive_little_bastard!
 => nil
E, [2011-10-05T17:54:33.582990 #3929] ERROR -- : JamesDean crashed!
JamesDean::CarInMyLaneError: that guy's gotta stop. he'll see us
/home/marubio/tmp/james_dean.rb:6:in `drive_little_bastard'
[...]
ruby-1.9.2-p180 :005 > james
 => #

Cuando le dijimos a james de forma asíncrona que condujese Little Bastard, ¡lo mató! Si fuésemos Elizabeth Taylor, co-protagonista de la última película al tiempo de su muerte, querríamos saber cuando murió. ¿Cómo podemos hacer eso? Enlazando a los actores que estén interesados en las caídas de otros actores. Para recibir estos eventos, necesitamos usar el método trap_exit. Un ejemplo:

class ElizabethTaylor
  include Celluloid::Actor
  trap_exit :actor_died
 
  def actor_died(actor, reason)
    puts "Oh no! #{actor.inspect} ha muerto por #{reason.class}"
  end
end

Por lo que al ejecutar lo siguiente, obtenemos:


ruby-1.9.2-p180 :001 > require "celluloid"
 => true
ruby-1.9.2-p180 :002 > require "./james_dean.rb"
 => true
ruby-1.9.2-p180 :003 > require "./elizabeth_taylor.rb"
 => true
ruby-1.9.2-p180 :004 > james = JamesDean.spawn
 => #
ruby-1.9.2-p180 :005 > elizabeth = ElizabethTaylor.spawn
 => #
ruby-1.9.2-p180 :006 > elizabeth.link james
 => #
ruby-1.9.2-p180 :007 > james.drive_little_bastard!
 => nil
E, [2011-10-06T11:26:31.659461 #8552] ERROR -- : JamesDean crashed!
JamesDean::CarInMyLaneError: that guy's gotta stop. he'll see us
ruby-1.9.2-p180 :008 > Oh no! # ha muerto por JamesDean::CarInMyLaneError

Como vemos, Elizabeth es notificada inmediatamente a través del trap, permitiéndole reaccionar ante la caída de James. Pero también podríamos querer lanzar un objeto y enlazarlo al mismo tiempo.

Conclusiones

El resto del tutorial (en inglés) se encuentra en la página oficial de Celluloid, donde se mencionan otras formas de enlazado, registro y logs. Yo me quedo en este punto, porque creo que ha sido suficiente para adentar la programación de Modelo Actor al lenguaje Ruby. Espero que os sirva para resolver algún que otro problema de programación en el que usualmente se empleen semáforos, monitores o memoria compartida.

]]> http://bosqueviejo.net/2011/10/06/celluloid-concurrencia-en-ruby/feed/ 0 Ruby: reescritura y yield http://bosqueviejo.net/2011/03/24/ruby-reescritura-y-yield/ http://bosqueviejo.net/2011/03/24/ruby-reescritura-y-yield/#comments Thu, 24 Mar 2011 12:32:54 +0000 bombadil http://bosqueviejo.net/?p=625 Durante unas pruebas en el trabajo, enseñando a mi mujer (Marga), cómo funciona Ruby con su mayor potencia, la reescritura de código y los yield, pensé… con lo que me ha costado… mejor lo guardo en el blog… y esto es :-)

Orientación a Objetos, no a Clases

Teniendo en cuenta de que Ruby es un lenguaje orientado a objetos (y no a clases), huelga decir que, no solo se puede redefinir una clase (es decir, el objeto plantilla del que se generan otros objetos), sino que también se puede redefinir un objeto instanciado sin que afecte al resto de objetos del mismo tipo.

Sobre la orientación a objetos de Ruby, vamos a hacer este simple ejercicio desde irb para que se pueda ver algo más claro:

class A
end
 
a = A.new
 
a.class   # A
A.class  # Class
Class.class # Class

Como se puede ver, el objeto a es de tipo A, el objeto (que no clase) A es de tipo Class, y el objeto (que tampoco clase) Class es recursivo en sí mismo, ya que Class es el tipo raíz del que parten todos los objetos… como en Java lo es Object.

Reescribiendo Clases

Una de las mayores potencias de Ruby, es que una clase definida, se puede redefinir, ya sea para cambiar un comportamiento específico, o para agregarle mayor funcionalidad. Esto de cara a la programación orientada a objetos, es una aberración, realmente, porque rompe la encapsulación… peeeero, de cara al pragmatismo, es muy útil poder modificar un comportamiento general para adaptarlo a uno específico sin necesidad de tener que reescribir de qué clase se hereda.

Haciendo una prueba:

class A
end
 
a = A.new
puts a    # #<A:0x000000000000>
 
class A
  def to_s
    "Clase A"
  end
end
 
puts a    # Clase A
 
b = A.new
 
class << b
  def to_s
    "objeto b"
  end
end
 
puts b    # objeto b
puts a    # Clase A

Con esto se puede comprobar, que la redefinición de métodos se puede conseguir, tanto para objetos como para clases.

Y ahora… el yield

Otra de las potencias de Ruby es que, podemos definir un código, dejando una definición a medias para poder ampliarla en el momento el que sea llamada, por ejemplo:

def ordena( vector )
     (0..(vector.size-2)).each do |i|
         k = i
         (i+1..(vector.size-1)).each do |j|
             k=j if yield(vector[k], vector[j])
         end
         if k!=i
             tmp = vector[k]
             vector[k] = vector[i]
             vector[i] = tmp
         end
     end
end
 
vector = [ 5, 3, 2, 4, 6, 1 ]
 
ordena(vector) do |e1, e2|
    (e1 > e2)
end
 
puts vector  # [1, 2, 3, 4, 5, 6]
 
ordena(vector) do |e1, e2|
    (e1 < e2)
end
 
puts vector  # [6, 5, 4, 3, 2, 1]

En este ejemplo de código, la función yield no está definida, sino que equivale al bloque de código que se especifica más tarde, cuando se llama a la función ordena, en el caso mostrado, es como si las funciones yield fuesen en el primer caso:

def yield(e1, e2)
    (e1 > e2)
end

Y en el segundo caso, exactamente igual pero cambiando la comparación para que la ordenación sea en sentido descendente.

La definición del código es in-situ, en el momento de usarse es cuando se especifica qué hace yield.

Se puede hacer algo más complejo, por ejemplo, cambiando el array de enteros por un array de objetos específicos que tengan una comparación algo más complicada. Aún así, el código de ordena no habría que cambiarlo. Solo la llamada, y su bloque adjunto.

Conclusiones

Para los que no conozcan bien Ruby, esto les habrá sonado a chino, para los que lo conozcan bien, quizás algo ya más que sabido, pero lo importante, es que se tenga claro el concepto y lo que se puede hacer, ya que, la necesidad, de seguro, surgirá después.

]]> http://bosqueviejo.net/2011/03/24/ruby-reescritura-y-yield/feed/ 0 Bundler: despliega fácilmente rails http://bosqueviejo.net/2011/03/07/bundler-despliega-facilmente-rails/ http://bosqueviejo.net/2011/03/07/bundler-despliega-facilmente-rails/#comments Mon, 07 Mar 2011 19:10:46 +0000 bombadil http://bosqueviejo.net/?p=615 Después de haber dado una vuelta por la versión estable de rails, he reparado en que, por defecto, se instala bundler y un fichero llamado Gemfile en la raiz de cada proyecto rails que se genera nuevo.

La verdad es que, en el momento que vi el fichero de Gemfile, queda clara la misión de dicho fichero, ya que viene con una colección básica de gemas que se suelen instalar de forma base cuando se trabaja con rails (out of the box) y unos comentarios de gemas que aconsejan para ciertos usos cotidianos (opcionales).

Indagando un poco, topé con su web, en la que viene cantidad de documentación sobre su uso y, ejecutando, simplemente, desde la consola:

bundle install

Me encuentro con que el sistema comienza a instalar rails y todos los paquetes base necesarios para poder tener el proyecto activo y funcionando sin problemas.

Esta es otra de las joyas que hacen que Ruby on Rails sea fácil de usar para el desarrollo rápido de aplicaciones web. Lo recomiendo, merece la pena.

]]> http://bosqueviejo.net/2011/03/07/bundler-despliega-facilmente-rails/feed/ 0 Banco de Pruebas (I): velocidad http://bosqueviejo.net/2010/11/15/banco-de-pruebas-i-velocidad/ http://bosqueviejo.net/2010/11/15/banco-de-pruebas-i-velocidad/#comments Mon, 15 Nov 2010 15:33:20 +0000 bombadil http://bosqueviejo.net/?p=536 Hace tiempo hice algo parecido con los lenguajes de programación que entonces conocía, probando aquellos que eran de scripting, compilados y probando sobretodo, lo que tardan en levantar y hacer una operación tan simple como enumerar 100.000 números sacando por pantalla el número con un elevado a 2 de la posición en el que sale la impresión. Por ejemplo:

Hola 1
Hola 4
Hola 9
Hola 16
...

He realizado las pruebas en los lenguajes: C, Perl, Ruby, Python, PHP, Lua, Shell script, Erlang script y Java.

C

En lenguaje C se ha realizado el siguiente código:

#include <stdio.h>
 
main() {
        int i;
 
        for (i=0; i<100000; i++) {
                printf("Hola %d\n", i*i);
        }
}

Perl

En el lenguaje Perl, se ha implementado el código siguiente:

#!/usr/bin/perl
 
for ($i=0; $i<100000; $i++) {
        print "Hola " . ($i*$i) . "\n";
}

Ruby

En Ruby, el código escrito ha sido:

#!/usr/bin/ruby
 
(1..100000).each do |i|
        puts "hola " + (i*i).to_s
end

Python

En Python, el código ha sido:

#!/usr/bin/python
 
for i in range(1,1000000):
        print "Hola " + str(i*i)

PHP

En PHP el código escrito ha sido:

#!/usr/bin/php -q
<?php
 
for ($i=0; $i<100000; $i++) {
        print "Hola " . ($i*$i) . "\n";
}

Lua

El código de Lua escrito ha sido:

#!/usr/bin/lua
 
for i=1,100000 do
        print("Hola " .. (i*i))
end

Shell script

En shell script (en bash) se ha implementado lo siguiente:

#!/bin/bash
 
for i in $(seq 1 100000); do
        let RESULT=$i*$i
        echo "Hola $RESULT"
done

Erlang (Script)

Erlang también puede emplearse como lenguaje de scripting usando el intérprete escript. El código escrito para este intérprete ha sido:

#!/usr/bin/escript
 
main(_Args) ->
        loop(100000).
 
loop(0) -> 0;
loop(I) ->
        io:format("Hola ~p~n", [I*I]),
        loop(I-1).

Java

El código que se ha usado para la prueba de Java ha sido:

public class loop {
        public static void main( final String[] args ) {
                for (int i=0; i<100000; i++) {
                        System.out.println("Hola " + (i*i));
                }
        }
}

Resultado de las pruebas

Tras ejecutar 5 veces cada script, controlando el tiempo que toma cada uno hemos obtenido, según el equipo en el que se ha ejecutado. El equipo 1 es un Intel vPro con Debian GNU/Linux Lenny:

Lenguaje Ejecuciones (en segundos) (Equipo 1)
1 2 3 4 5
C (4.1.3) 0,02 0,02 0,02 0,02 0,02
Perl (5.10.0) 0,04 0,03 0,03 0,03 0,03
Ruby (1.8.7-p72) 0,16 0,15 0,16 0,16 0,15
Lua (5.1.3) 0,21 0,22 0,21 0,21 0,21
PHP (5.3.1) 0,41 0,47 0,43 0,33 0,29
Python (2.6.5) 1,13 1,11 1,15 1,16 1,14
Java (1.6.0_20-b02) 1,37 1,39 1,40 1,36 1,34
Erlang (R13B04, 5.7.5) 3,65 3,62 3,65 3,65 3,56
Bash (3.2.39) 7,27 7,26 7,46 7,40 7,25

En el equipo 2, un Apple iBook G4 (PowerPC):

Lenguaje Ejecuciones (en segundos) (Equipo 2)
1 2 3 4 5
C (4.0.1) 0,22 0,34 0,55 0,32 0,35
Perl (5.8.9) 0,67 0,83 0,68 0,68 0,78
Ruby (1.8.6-p386) 2,91 3,21 3,20 3,13 3,52
Lua (5.1.4) 1,51 1,64 1,64 1,65 2,43
PHP (5.2.14) 2,51 2,48 2,55 2,37 2,77
Python (2.5.1) 17,49 16,91 17,41 17,40 16,92
Java (1.5.0_26-156) 7,60 5,92 5,72 5,90 6,02
Erlang (R14A, 5.8) 22,10 23,13 22,76 21,94 21,80
Bash (4.1.9) 135,19 223,56 181,40 136,19 133,46

Ordenados por velocidad, se ve que el lenguaje C, como cabía esperar, es el más rápido, seguido de Perl, como el lenguaje de scripting más rápido.

]]> http://bosqueviejo.net/2010/11/15/banco-de-pruebas-i-velocidad/feed/ 0 ¡Shoes vive! http://bosqueviejo.net/2010/04/14/shoes-vive/ http://bosqueviejo.net/2010/04/14/shoes-vive/#comments Wed, 14 Apr 2010 08:36:24 +0000 bombadil http://bosqueviejo.net/?p=392 Hace tiempo escribí una entrada sobre este entorno de programación para GUI de Ruby, desde ahí a unos meses después, el creador del entorno, denominado why en la red, cerró todo su material en la red, eliminó su twitter, sus webs y dominios, eliminó sus códigos de github, etc.

Después de esta acción, shoes murió… era muy complicado encontrar un sistema shoes que funcionase y se compilase con las nuevas versiones de ruby, así como un tutorial tan completo como el que tenía why en su propia página web.

No obstante, en este mismo año, mental y más gente en la red, ha ido recopilando de las cachés y de lo que guardaban entre unos y otros y, amparándose en las licencias con las que fueron publicadas cada cosa, han vuelto a poner, eso sí, en otros enlaces distintos, cada una de las cosas que why dió de baja de Internet (salvo su twitter, claro).

La nueva web: http://hacketyhack.heroku.com

El código fuente se puede descargar de aquí.

]]> http://bosqueviejo.net/2010/04/14/shoes-vive/feed/ 0 Programando en Ruby http://bosqueviejo.net/2010/03/11/programando-en-ruby/ http://bosqueviejo.net/2010/03/11/programando-en-ruby/#comments Thu, 11 Mar 2010 09:40:06 +0000 bombadil http://bosqueviejo.net/?p=358 Llevo tiempo escribiendo sobre este lenguaje de programación, como una joya redescubierta, ahora me gustaría centrarme en un libro que leí hace tiempo, pero que me resultó muy útil para comprender y adentrarme mejor en este lenguaje.

Programming Ruby
; Pragmatic Bookshelf 2008
 

Este libro, escrito por uno de los firmantes del manifiesto ágil (Dave Thomas) y otro de ellos como co-autor (Andy Hunt), es un libro que tiene en su interior, no solo el aprendizaje del lenguaje en sí, sino de una metodología de programación, una suma de buenas prácticas de programación que se orientan a sacar el mejor partido del lenguaje potenciando sus fortalezas y aprovechándolas con patrones de desarrollo ágiles que mejoran y potencian su uso.

Recomiendo el libro a todos aquellos que quieran adentrarse en la programación en ruby de la mano de personas que desarrollan día a día con él desde hace mucho tiempo, y no se han quedado estancadas (prueba de ello es que este libro es segunda edición y en 2008 salió la tercera edición, el cual no he podido leer aún, pero promete mayor y mejor contenido).

]]> http://bosqueviejo.net/2010/03/11/programando-en-ruby/feed/ 0