Blog de javiyu

Ejecución asíncrona de javascript con web workers

2009-11-01T16:46:00.006+01:00

Tal y como anunciaba Google en la Google IO de este año han estado trabajando junto a la fundación Mozilla en la definición e implementación de los llamados web workers.

Los web workers permiten carga y ejecución asíncrona de javascript, tienen algunas limitaciones ya que no se puede acceder al DOM entre otras funciones, usa threads a nivel de sistema operativo y usa como método de sincronización paso de mensajes.

Un ejemplo de sincronización sencillo.

long_work.js


var j=1;
for(var i=0; i<999999999; i++){j=j*7+2;j=1}
this.postMessage('Done');

index.html


<script type="text/javascript">
     var worker = new Worker("/javascripts/long_work.js");
     worker.onmessage = function(event){
       alert(event.data);
     };
</script>

Ejemplo de uso en la web de la fundación Mozilla.

Como hacer copias de seguridad de tu agenda en symbian

2009-08-15T22:50:00.002+02:00

Ya que tenemos acceso al API de symbian desde python (gracias al proyecto pys60) podemos aprovecharnos para hacer algunas cosas útiles con unos scripts simples en python.

Por ejemplo, para hacer una copia de seguridad de la agenda serviría el siguiente script.


from contacts import ContactsDb

contacts = ContactsDb().values()

filename = 'e:\\agenda.txt'
f = open(filename, "w")

for c in contacts:
 f.write(c.as_vcard())

f.close()

Este programa exporta a un fichero toda la agenda en formato VCard para posteriormente transferirlo a otro dispositivo.

Conectar una aplicación rails a varias bases de datos simultáneamente

2009-07-18T16:54:00.003+02:00

Se puede conectar una aplicación rails a varias bases de datos a la vez, eso sí, hay que tener un especial cuidado con el rendimiento de la aplicación, aunque ActiveRecord nos provee una interfaz transparente a la hora de acceder a los modelos.

Suponiendo como ejemplo que tenemos dos modelos (Post y Comment) y este último está localizado en una base de datos externa, se puede configurar rails de la siguiente forma:

1) Primero, creamos un fichero de configuración para la conexión a la nueva base de datos (config/external_database.yml).


development:
    adapter: mysql
    database: test
    username: root
    password:

production:
    adapter: mysql
    database: test
    username: root
    password:

2) Después, creamos un módulo para encapsular la lectura del fichero y la nueva conexión.


module ExternalDatabase
  def self.included(base)
    config = YAML.load(File.open('config/external_database.yml'))    
    
    if config and ENV['RAILS_ENV']
      base.establish_connection(config[ENV['RAILS_ENV']])
    else
      raise 'External Database not configured'
    end
  end
end

3) Por último, incluimos en los modelos que van a la base de datos externa el módulo que hemos creado.


class Comment < ActiveRecord::Base
  include ExternalDatabase
  
  belongs_to :post
end

Con esto ya podemos utilizar los modelos aunque cada uno esté en una base de datos diferente.


Comment.find(:all, :include => :post)

Diferencias de rendimiento entre eval y send

2009-07-11T15:55:00.002+02:00

La metaprogramación en ruby permite mucha expresividad y flexibilidad, aún así hace caer bastante el rendimiento.

A pesar de eso, lo más importante es evitar en la medida de lo posible eval ya que es bastante más lento.

Al hacer una llamada a send la máquina virtual de ruby tiene que buscar el nombre del método que se le pasa como parámetro y ejecutarlo.

En cambio, al hacer un eval además de lo anterior la máquina virtual necesita parsear la cadena y después ejecutar el código.


Benchmark.bm{|x| x.report{100000.times{eval('Post.scopes')}}}
    user     system      total        real
0.410000   0.000000   0.410000 (  0.410306)

Benchmark.bm{|x| x.report{100000.times{Post.send('scopes')}}}
    user     system      total        real
0.140000   0.000000   0.140000 (  0.144820)

Optimización de consultas en rails

2009-06-26T18:39:00.005+02:00

Cuando en rails se hace una consulta a la base de datos sobre una tabla que contiene mucha información, no todo el tiempo se pierde en la consulta. Una parte importante del tiempo se pierde en la creación de cada objeto ActiveRecord.

Usando directamente el método select_all de la conexión ActiveRecord devolverá un array de hash, ahorrando el tiempo de construcción de objetos.


Benchmark.bm{|x| x.report{100.times{BigTable.find(:all)}}}
    user     system      total        real
10.090000   2.090000  12.180000 ( 19.199150)

Benchmark.bmbm{|x| x.report{100.times{BigTable.connection.select_all('select * from big_table')}}}
    user     system      total        real
7.350000   2.080000   9.430000 ( 16.646406)

En general, no es buena idea guardar todos los elementos de una tabla grande en un array, pero aún seleccionando tan solo el índice se obtiene una mejora sustancial.


Benchmark.bm{|x| x.report{100.times{BigTable.find(:all, :select => :id)}}}
    user     system      total        real
0.610000   0.010000   0.620000 (  0.707702)

Benchmark.bmbm{|x| x.report{100.times{BigTable.connection.select_all('select id from big_table')}}}
    user     system      total        real
0.080000   0.000000   0.080000 (  0.161878)

Crear extensiones de ruby en c

2009-06-20T23:19:00.006+02:00

Crear extensiones en C del lenguaje ruby es bastante sencillo.

En primer lugar hay que crear un fichero para extconf, este nos generará el fichero makefile de forma automática.

En el fichero extconf.rb debería haber algo como:


#!/usr/bin/env ruby

require 'mkmf'
create_makefile("ruby1")

Donde ruby1 es el nombre de la extensión.

En segundo lugar hay que crear la extensión en código C, simplemente hay que incluir la cabecera ruby.h.

La función Init_ruby1 es la que se ejecutará al importar la extensión desde código ruby.


#include "ruby.h"

static VALUE c_printf(VALUE self, VALUE anObject){
 printf("%s\n", STR2CSTR(anObject));
 return Qnil;
}

static VALUE c_init(VALUE self){
  return self;
}


VALUE FromC;

void Init_ruby1() {
 rb_define_global_function("printfc", c_printf, 1);
 FromC = rb_define_class("FromC", rb_cObject);
 rb_define_method(FromC, "initialize", c_init, 0);
 rb_define_method(FromC, "printfc", c_printf, 1);
}

En este ejemplo se define una función global printfc, se define la clase FromC, el método de instancia printfc de esa clase.

Para compilar e instalar este código hay que ejecutar ruby extconf.rb, make y make install.

Ya deberíamos tener disponible la librería ruby1, al ejecutar require 'ruby1' podremos ejecutar las funciones de nuestro código en C.

Hay una gran cantidad de funciones disponibles para crear extensiones en la siguiente dirección: http://www.rubycentral.com/book/ext_ruby.html

Definición de named_scopes dependientes del tiempo actual

2009-06-03T23:42:00.005+02:00

Si tenemos una clase ActiveRecord como la siguiente:


class Post < ActiveRecord::Base
  named_scope :test, :conditions => ['updated_at < ?', Time.now]
end

En modo development funciona sin problemas, sin embargo en modo production la consulta que se genera no es la esperada.

Al arrancar rails en modo production se cachean las clases, al cargar este modelo en concreto se evalúa Time.now haciendo que para todas las consultas se coja como fecha la hora en la que se ha cargado el modelo.

El descrito anteriormente no es el comportamiento que esperaríamos al definir el named_scope, sino que debería obtener la fecha y hora actual para cada consulta, no en la definición.

Revisando la definición de los named_scopes nos encontramos lo siguiente:


      def named_scope(name, options = {}, &block)
        name = name.to_sym
        scopes[name] = lambda do |parent_scope, *args|
          Scope.new(parent_scope, case options
            when Hash
              options
            when Proc
              options.call(*args)
          end, &block)
        end
        (class << self; self end).instance_eval do
          define_method name do |*args|
            scopes[name].call(self, *args)
          end
        end
      end

En nuestro caso pasamos un hash como opciones, por lo que efectivamente se evaluará el Time.now solo en la definición de dicho hash.

Si en lugar de eso definimos un objeto de tipo Proc se evaluará cada vez.

Por lo tanto para arreglar el comportamiento del primer ejemplo deberíamos escribirlo como:


class Post < ActiveRecord::Base
  named_scope :test, lambda{{:conditions => ['updated_at < ?', Time.now]}}
end

Aplicación de consola para twitter

2009-05-10T23:20:00.004+02:00

Acabo de lanzar un proyecto en github para interaccionar con twitter desde consola.

Por ahora incluye la funcionalidad básica: cambio de estado, consulta de estado de amigos, login y mensajería.

La interfaz de comandos es muy similar al clásico IRC.

La url del proyecto es la siguiente: twit

Añadiendo estado a los elementos del DOM

2009-05-01T13:32:00.003+02:00

En aplicaciones complejas con javascript para guardar el estado de cada elemento se suele modificar alguna propiedad del elemento que queramos manipular.

Sin embargo esta práctica es poco adecuada y no demasiado flexible, ya que no podemos guardar tipos de datos complejos.

jQuery ya prevee que podemos necesitar esta funcionalidad y nos proporciona la función data para guardar información de cada elemento.

Por ejemplo:


$('a').data('activated_links', false);
....
var footer_links = $('.footer_links');
if(!footer_links.data('activated_links')){
  footer_links.data('activated_links', true);
  ...
}
...

Combinación de named_scopes en rails

2009-03-28T12:30:00.002+01:00

Cuando hay que realizar un filtrado de resultados en una web con muchas posibles combinaciones podemos acabar con muchas líneas de código para obtener una funcionalidad no demasiado compleja.

En rails, la mayoría de los filtrados se hacen con named_scopes, queda parcialmente resuelto el problema, aún así quedan resolver como aplicar cada combinación de named_scopes según el filtrado que necesite el usuario.

Suponiendo que tenemos un modelo Post como el siguiente:


class Post < ActiveRecord::Base
  named_scope :all
  named_scope :published, :conditions => {:published => true}
  named_scope :from_user, :conditions => {:kind => 'user'}
  named_scope :from_admin, :conditions => {:kind => 'admin'}
end

Podemos resolver el problema de aplicar filtros combinados de la siguiente forma usando inject:


class PostsController < ApplicationController
  def index
    filter = (params[:filter] or String.new)
    filter = filter.split(',').map(&:to_sym).select{|f| Post.scopes.include?(f)}
    filter << :all

    @posts = filter.inject(Post){|model, nscope| model.send(nscope)}
  end
end

En primer lugar obtenemos la lista de named_scopes a aplicar y filtramos los no válidos, en segundo con inject se los aplicamos al modelo.

Con ese código tan simple podemos usar rutas del tipo:

http://server/posts
http://server/posts?filter=published
http://server/posts?filter=published,from_user

Optimización del tiempo de carga de webs

2009-03-01T14:58:00.003+01:00

Dentro del tiempo total desde que se hace una petición a una página web hasta que se termina de dibujar en el navegador, gran parte corresponde a los distintos recursos externos que hay que recuperar: javascript, css e imágenes.

Los ficheros javascript y css tienen una propiedad interesante, si se concatenan varios y se envían en un solo fichero no debe influir en el resultado final.
Sin embargo, si se concatenan, se pueden cargar con una sola petición, con el consiguiente aumento de rendimiento.

El método que rails proporciona para hacer esto de forma automática es el siguiente (solo en modo producción):


<%= javascript_include_tag 'first.js', 'second.js', :cache => '1_2' %>

Sin embargo esto tiene un problema, normalmente en una aplicación según la página se carga unos ficheros u otros, no es muy práctico ir dándole claves a todas las combinaciones.

Se pueden programar dos helpers para dar las claves de forma automática:


<%= cached_javascript_include_tag 'first.js', 'second.js' %>
<%= cached_stylesheet_link_tag 'first.css', 'second.css' %>

Es importante que las versiones cacheadas tanto de css como de javascript no estén en el svn, a la hora de hacer un despliegue se regenerarán usando la nueva versión de los ficheros.

Aún así, si se quiere que se genere de nuevo la versión cacheada para una página sin desplegar la aplicación ni borrar los ficheros antiguos, se puede usar un sistema de versiones.


<%= cached_javascript_include_tag 'first.js?v=1', 'second.js?v=3' %>

El código de los helpers es el siguiente:


module ApplicationHelper
  def cached_javascript_include_tag(*args)
    cached_args!(*args)
    javascript_include_tag(*args)
  end

  def cached_stylesheet_link_tag(*args)
    cached_args!(*args)
    stylesheet_link_tag(*args)
  end

  def cached_args!(*args)
    options = args.extract_options!.stringify_keys

    cache_entry = args.map(&:to_s).sort.join('_').gsub!('?', '_')
    options[:cache] = cache_entry

    args << options
  end
end

Observadores personalizables en rails

2009-01-11T11:43:00.002+01:00

En rails hay unas clases llamadas observadores que sirven para redefinir los métodos que necesitemos en el ciclo de vida de los objetos (after_update, before_create, etc...).

El problema es que en ocasiones con los métodos del ciclo de vida no es suficiente, una situación muy común es redefinir el método after_save, y cada vez que se guarde un objeto comprobar una condición y actuar si es necesario.

Afortunadamente existe un método en ActiveRecord para notificar a los observadores exactamente cuando queramos y de lo que queramos, de la siguiente forma.

En el modelo:


class Post < ActiveRecord::Base
 def just_created
  notify :manage_task
 end
end

En el observador:


class GlobalObserver < ActiveRecord::Observer
 observe Post
 
 def manage_task(object)
  #do something
 end
end

Carga de css dinámica

2009-01-02T18:33:00.002+01:00

Es habitual en webs en las que cada usuario tiene una página personal permitirle cambiar la apariencia mediante temas (skins).

Para cargar un css nuevo de forma dinámica se puede usar la siguiente función javascript o algún variante.


function loadCSS(cssFile){
 var cssLink=document.createElement("link");
 cssLink.setAttribute("rel", "stylesheet");
 cssLink.setAttribute("type", "text/css");
 cssLink.setAttribute("href", cssFile);
 document.getElementsByTagName("head")[0].appendChild(cssLink);
}

Lo que hace esta función es crear un elemento link que apunta a un css y lo inserta en el head de la página.

Crear demonios en ruby

2008-12-28T00:03:00.003+01:00

Para crear un demonio hay que duplicar el proceso actual (hacer un fork) y distinguir a cada una de las instancias para la que instancia hija se encargue del trabajo en background que queremos realizar.

En ruby todo este proceso se puede realizar automáticamente utilizando el módulo ruby daemon de la siguiente forma.


require 'daemons'

class Demonio
 def initialize
  Daemons.daemonize
  loop do
   f = File.new('/tmp/timestamp', 'a')
   f.write("#{Time.now}\n")
   f.close
   sleep(3)
  end
 end
end

Demonio.new

Redefinir el método de comparación con expresiones regulares

2008-12-26T23:44:00.004+01:00

Para mejorar la búsqueda en los datos de los objetos se puede aprovechar que en ruby se puede redefinir el método de comparación con expresiones regulares (=~).

Un ejemplo.


class Persona
 attr_accessor :nombre, :apellidos, :direccion
 
 def initialize(nombre, apellidos, direccion)
  self.nombre = nombre
  self.apellidos = apellidos
  self.direccion = direccion
 end 
 
 def =~(re)
  "#{self.nombre} #{self.apellidos} #{self.direccion}" =~ re
 end
 
 def self.search(ciudad, input)
  query = Regexp.new(input, 'i')
  ciudad.select{|p| p =~ query} 
 end
end



p1 = Persona.new('Jose', 'Gonzalez', 'Sol')
p2 = Persona.new('Francisco', 'Martinez', 'Preciados')
p3 = Persona.new('Fernando', 'Solano', 'Serrano')

Madrid = [p1, p2, p3]

puts Persona.search(Madrid, 'sol').map(&:nombre)

El modificador 'i' del constructor de expresiones regulares hace que no distinga entre mayúsculas y minúsculas.
Concatenando los campos en los que queremos buscar se obtiene un matching más completo.

Con el map final se imprimen los nombres de las personas que hayan coincidido con la búsqueda.

Recuperación automática de procesos erlang

2008-12-14T13:09:00.004+01:00

La mayor ventaja que proporciona erlang es la gran potencia que tiene para la programación de procesos concurrentes.

Cuando se diseña software que va a ser programado en erlang suele dividirse el trabajo en múltiples procesos, además provee de mecanismos para comprobar fácilmente entre procesos si alguno se ha colgado y restaurarlo o ejecutar cualquier otra acción.

En el siguiente ejemplo.


-module(lib_misc).
-export([link_p/1, start/0, loop/0]).

start() -> 
 Pid = spawn(fun loop/0),
 register(divisor, Pid),
 spawn(lib_misc, link_p, [Pid]),
 Pid.

loop() ->
 receive
  {A, B} ->
   io:format("~nDivision: ~p", [A/B]),
   loop()
 end.


link_p(Pid) ->
 process_flag(trap_exit, true),
 link(Pid),
 receive
  {'EXIT', Pid, _} -> 
   NewPid = spawn_link(lib_misc, loop, []),
   register(divisor, NewPid),
   link_p(NewPid)
 end.

Al compilar la librería y arrancarla se ejecutan dos procesos, el principal loop y otro llamado link_p.

El bucle principal simplemente recibe una tupla con dos números y los divide. Tiene al menos un error conocido y es que no comprueba cuando el divisor es cero.

El proceso link_p se enlaza al principal, la tarea de este proceso es esperar a que el principal se cuelgue (por ejemplo, división entre cero).
En el momento en el que el programa principal se ha colgado, recibe el mensaje de salida, restaura el proceso y se enlaza al nuevo.

Hay un detalle más, al iniciar un nuevo proceso el pid del antiguo no nos sirve para mandarle mensajes, así que se registra el átomo divisor para tener siempre una referencia global.

Registrar un nombre global estático no es la mejor solución, ya que no se pueden iniciar múltiples instancias del proceso divisor, debería ser un parámetro, lo he dejado así por que el ejemplo fuera más sencillo.

Funciones anónimas recursivas en Erlang

2008-12-08T11:24:00.002+01:00

En erlang se pueden definir funciones anónimas con la palabra reservada fun, aunque se pueden guardar en una variable para referenciarlas posteriormente.

La sintaxis es la siguiente:

IsZero = fun(0) -> 1; (N) -> 0 end.

Esta función devuelve 1 (verdad) si el parámetro es 0, falso en cualquier otro caso.

El problema es que de esta forma no se pueden definir funciones recursivas, ya que al no estar definida la función dentro de su definición, no podemos referenciarla, para solucionarlo se puede pasar un parámetro extra, que sea la propia función.

Factorial = fun(1, F) -> 1; (N, F) -> N * F(N-1, F) end.

En este último caso habría que llamar a la función como Factorial(número, Factorial), lo que queda poco intuitivo, se puede mejorar creando dos funciones en lugar de una.

Fact = fun(1, F) -> 1; (N, F) -> N * F(N-1, F) end.
Factorial = fun(N) -> Fact(N, Fact) end.

Terminales virtuales en linux

2008-11-30T19:03:00.002+01:00

Regularmente cuando administramos equipos unix necesitamos varios terminales, por ejemplo, en el caso de estar administrando un equipo linux remoto por ssh.

Para poder tener varios terminales podemos loguearnos varias veces y usar cada conexión como un terminal, sin embargo esto está lejos de ser óptimo, una sola conexión es más que suficiente para tener abiertas varios terminales.

El comando screen de linux permite crear terminales virtuales, por lo que este problema lo tendríamos resuelto, su funcionamiento es muy simple.

Ejecutando:

sreen bash, abrimos una instancia nueva de bash en otro terminal.

Ctrl+A ", muestra una lista de los terminales virtuales.

Ctr+A 2, va a la tercera consola virtual (numeradas desde 0).

Ctrl+A Ctrl+A, va a la consola mostrada anteriormente.

Ctrl+A d, deja ejecutando las tareas en background (detach).

Expiration time en fragment caching

2008-11-30T12:49:00.005+01:00

Cuando se usa el sistema de caché de rails se pueden elegir donde guardar los items cacheados, la mejor opción es la mayoría de los casos es memcached, pero no siempre tenemos posibilidad de instalar un demonio en la máquina que da hosting.

Otra posibilidad es guardar los items en el sistema de ficheros, para ello hay que añadir en el environment.rb lo siguiente.


config.cache_store = :file_store, '/path_to_cache'

El problema que tiene usar el sistema de ficheros como soporte para la cache es que no soporta la opción de expiración por tiempo, sin embargo memcached sí que lo hace.

Se puede solucionar añadiendo el siguiente parche al environment.rb


module ActiveSupport
  module Cache
    class FileStore < Store
      def read(name, options = nil)
        super
        timestamp = File.open("#{real_file_path(name)}.timestamp", 'rb') { |f| f.read } rescue nil
        if !timestamp or (timestamp and timestamp.to_i > Time.now.to_i)
          File.open(real_file_path(name), 'rb') { |f| f.read } rescue nil
        else
          nil
        end
      end

      def write(name, value, options = nil)
        super
        ensure_cache_path(File.dirname(real_file_path(name)))
        if options and options[:expires_in] 
          File.open("#{real_file_path(name)}.timestamp", "wb+") { |f| f.write(Time.now.to_i + options[:expires_in].to_i) } 
        end
        File.open(real_file_path(name), "wb+") { |f| f.write(value) }
      rescue => e
        RAILS_DEFAULT_LOGGER.error "Couldn't create cache directory: #{name} (#{e.message})" if RAILS_DEFAULT_LOGGER
      end

      def delete(name, options = nil)
        super
        File.delete("#{real_file_path(name)}.timestamp") rescue  nil 
        File.delete(real_file_path(name)) rescue nil
      end
    end
  end
end

Se puede utilizar al igual que la opción expires_in en memcached.


<% cache 'something', :expires_in => 5.minutes do %>
 Hello, just saying hello from cache
<% end %>

Lo he desarrollado teniendo en cuenta la implementación de rails 2.1.2, y solo soporta fragment caching.

Fragment caching en rails

2008-11-26T22:16:00.003+01:00

Usando memcached y fragment caching se puede acelerar mucho la reconstrucción de las vistas en rails.

Para ello, una vez instalado memcached lo ejecutamos:

memcached -d

Por defecto estará en el puerto 11211.

En el environment.rb hay que configurar la caché para que utilice memcached.


config.cache_store = :mem_cache_store

Tras eso en las vistas podemos hacer lo siguiente:


<% cache 'key', :expires_in => 300 do %>
  texto html...
<% end %>

300 es el número de segundos que este trozo estará vigente en caché, si no se indica nada el fragmento no expirará a no ser que lo indiquemos manualmente con expire_fragment.

key es la clave que tiene el fragmento dentro de la vista, es necesario para distinguir los distintos fragmentos.

Memoization en ruby

2008-11-15T23:37:00.009+01:00

La memoization es una técnica de optimización que consiste en recordar los resultados para anteriores llamadas a una función.

Si para una llamada anterior a una función se han pasado los parámetros x=2 e y=3, la próxima vez se devolverá el mismo resultado al obtenido, sin repetir cálculos.

La implementación es muy sencilla y se pueden obtener mejoras muy significativas en funciones con cálculos pesados, basta con tener una tabla en la que utilicemos los parámetros de entrada como índices y el resultado de la función como valor.

Si ya de por sí es sencillo implementar la memoization en ruby se puede usar también la gema que hay específica para ello, esta gema implementa la memoization automática, por lo que ni siquiera es necesario mantener una tabla para los valores, la gema se encarga de ello.

Es necesario recordar que en la memoization solo se tienen en cuenta los parámetros de entrada, por lo que a las funciones que produzcan resultados a partir de otras entradas (ficheros, hora actual...) no se les debe aplicar esta técnica.

En el siguiente ejemplo se implementa la función de fibonacci recursiva (fib1), la misma función aplicándole la memoization (fib2) y por último la memoization automática a fib1. En mi máquina para este ejemplo se obtienen ganancias de 30 a 40 veces en las versiones memoizadas.


require 'rubygems'
require 'memoize'

include Memoize

def fib1(n)
 return n if n < 2
 return fib1(n-1) + fib1(n-2)
end


@mm = {}
def fib2(n)
 return @mm[n] if @mm[n]
 return n if n < 2
 
 @mm[n] = fib2(n-1) + fib2(n-2)
 return @mm[n]
end

puts fib1(30)
puts fib2(30)

memoize(:fib1)
puts fib1(30)

Ocultar parámetros del log de rails

2008-11-09T15:28:00.002+01:00

Al igual que se suelen encriptar las contraseñas al guardarlas en las bases de datos de las aplicaciones con autentificación, también se deberían omitir este tipo de campos en el log de rails.

Cuando se despliega rails en un entorno en producción normalmente guarda el log de todas las peticiones en log/production.log, ahí se pueden ver todos los parámetros que se pasan a la aplicación, incluyendo contraseñas, números de tarjetas de crédito, etc.

Hay una forma de hacer que determinados parámetros no aparezcan, llamando a filter_parameter_logging en el controlador.

class AccountsController < ApplicationController
  filter_parameter_logging :card_number

  def index
    @accounts = Account.find(:all)
  end
end

En el log aparecerá algo así.

Parameters: {"card_number"=>"[FILTERED]"...

Generacion dinámica de métodos en ruby

2008-11-02T21:56:00.002+01:00

Una característica que puede añadir mucha potencia a los módulos que creamos en ruby es la generación automática de métodos.

Se usa intensivamente en rails, tanto en la implementación de ActiveRecord como de la mayoría de plugins.

Para definir métodos de forma dinámica tan solo hay que redefinir method_missing, este método se llama cada vez que se llama a una función no definida, recibe como primer parámetro el nombre del método y como segundo parámetro la lista de argumentos.

Dejo un ejemplo.

#!/usr/bin/ruby

def method_missing(method, *args)
 if method.to_s =~ /saludo_(\w+)/
  generar_saludo($1)
 else
  super(method, *args)
 end
end

def generar_saludo(msg)
 puts "hola #{msg}"
end


saludo_mundo

Crear clases dinámicas en ruby

2008-11-01T21:58:00.002+01:00

La sintaxis de ruby para crear clases u objetos es muy sencilla, pero lo es más aún para definirlos dinámicamente.

Para ello disponemos de la clase Struct, veamos un ejemplo en el siguiente código.

Clase = Struct.new :campo1, :campo2
objeto = Clase.new('valor1', 'valor2')
puts objeto.campo1
puts objeto.campo2
puts objeto.members
puts objeto.values

En la primera línea con Struct se crea la clase Clase con dos campos, esos campos ya están disponibles en los objetos que creemos a partir de la clase. Adicionalmente, Struct añade algunos métodos como members y values para inspeccionar el contenido de los objetos creados.

Metaprogramación en php

2008-10-26T22:05:00.002+01:00

En php5 han entrado nuevas posibilidades en lo que a metaprogramación se refiere, revisando el siguiente trozo de código nos encontramos un ejemplo de que construcciones se pueden realizar.

<?php

function saludo(){
        return "hello";
}

$cadena = "saludo";
$cadena_funcion = "cadena";
?>

<?= $cadena() ?>

<br/>

<?= $$cadena_funcion() ?>

Primero podemos ver que si guardamos en una cadena el nombre de una función, y luego llamamos a la cadena con una lista de parámetros (en este caso vacía), se invoca dicha función. Esto puede ser bastante útil para elegir que acción ejecutar ante una entrada por parámetro.

En segundo lugar se muestra como utilizar las variables con doble '$', es decir, las variables de variables. Por cada '$' delante del nombre de la variable se hace una evaluación de la variable.

$cadena_funcion contiene la cadena "cadena", si por el contrario se referencia a $$cadena_funcion, se evaluará la variable $cadena.