Esta es una solución que se me ocurrió para hacerme más cómodo el trabajo con
el atributo created_at de un modelo, por ej:

Para saber el año de creación de un post, haríamos lo siguiente:

>> p = Post.find(1)
>> p.created_at.month
=> 6

como podemos observar retorna 6, pero resulta que yo lo necesito necesito con el siguiente formato: “06″. Lo mismo pasa con el día:

>> p = Post.find(1)
>> p.created_at.day
=> 4

module ActsAsDate

  def year
    created_at.strftime("%Y")
  end

  def month
    created_at.strftime("%m")
  end

  def day
    created_at.strftime("%d")
  end

  def year_month
    [year, month]
  end

  # Armo un string para usarlo en un find
  #    ej:
  #   params = {:year => "2008", :month => "06"}
  #   Post.all(:conditions => Post.created_at_conditions(params))
  #
  def self.included(klass)
    klass.class_eval do
      def self.created_at_conditions(params)
        return nil if params[:year].blank? or params[:month].blank?
        "created_at like '#{params[:year]}-#{params[:month]}%'"
      end
    end
  end

end

Entonces tenemos que incluir este módulo en modelo que lo queremos usar:

class Post < ActiveRecord::Base

  include ActsAsDate

end

Ahora con esto directamente hago p.month, p.day, p.year y obtengo el mes, día y año de creación del post con el formato que necesito y escribiendo menos código :). Además agregué un método que me arma el param conditions, que se podría un usar así por ej:

class PostsController < ApplicationController

def list
    @posts = Post.paginate(
         :page => params[:page],
         :order => 'created_at DESC',
         :conditions => Post.created_at_conditions(params)
    )

    respond_to do |format|
      format.html
      format.xml  { render :xml => @posts }
    end
  end

end

De esta manera no tengo que estar preguntando en el controller si vienen (year y month) como parámetros, por ahora este modulo sólo funciona con el atributo created_at por que está hardcodeado, pero con pocas modificaciones se podría hacer que funciona para cualquier atributo.
Ahora lo que me pregunto es si Rails ya tiene alguna solución mejor para este problema, si alguien la conoce que me lo haga saber por favor (yo no la encontré), además se aceptan modificaciones, sugerencias y comentarios.

Muchas veces cuando estamos desarrollando una aplicación web necesitamos mirar cierta información de debug, acá les dejo una mi versión de este senippet que leí por acá .

La idea es poner este código en un partial:

 app/view/views/shared/_debug_info.html.erb

y luego ponemos el render en el layout de la aplicación:

 <%= render :partial => 'shared/debug_info' %>

Va el pastie: http://pastie.org/222621

Hace un tiempo que estoy probando rubunius (una máquina virtual para ruby desarrollada por Evan Phoenix inspirada en smalltalk-80) y además estoy colaborando con rubyspec un proyecto que nació como parte de rubinius. Rubinius está en proceso de desarrolllo, para probarlo hay que bajarse los fuentes y compilarlo, o… para los que usan debian o algunos de sus derivados pueden bajarse el siguiente .deb que cree hace algunos días, que lo disfruten :).

Rails agrega un nuevo método al módulo Enumerable. Vamos al código para explicar cómo funciona este nuevo método:

>> Post.all.many?
=> false
>> Post.create({:title => "hola", :post => "hola"})
>> Post.all.many?
=> false
>> Post.create({:title => "otro hola", :post => "otro hola"})
>> Post.all.many?
=> true
>> Post.all.size
=> 2
>> posts = Post.find(:all, :conditions => {:post => "hola"})
>> posts.many?
=> false
>> posts.size
=> 1

La función de este nuevo método many? es básicamente encapsular collection.size > 1, es un detalle bastante cómodo que opinan uds?

La semana pasada aprobé la última materia de la carrera Analista en Informática Aplicada, después de muuuucho tiempo al fin me recibí, todavía recuerdo cuando recién comenzaba a estudiar, tenía muchas energías y ganas de aprender más y más acerca de todo lo que tenga que ver con computadoras y debo reconocer que aprendí varias cosas en esa casa estudios pero también tengo que decir que las cosas que considero más importantes las aprendí afuera. En mi caso particular hace bastante tiempo que me vengo dedicando al desarrollo de software más que nada al desarrollo web, he trabajado en varios lugares/empresas y también hice algunos proyectos personales que publiqué con licencia GPL. En la facultad tuve materias como: Fundamentos de Programación, Programación I, Programación II, Ingeniería de Software, Bases de datos y Optativa y Proyecto final, los lenguajes que conocí en esas materias fueron: Pascal, Delphi, Java, C++ y Visual Basic, sin embargo los lenguajes en con los cuales yo he venido trabajando son: PHP, Perl, Ruby y algo de Shell Scripting… es cierto que en este último tiempo en mi trabajo me están obligando a usar java (uno de los motivos que hace que este lugar se torne bastante aburrido para mí). Debo decir que la mayoría de estas materias (de programación) estaban centradas en enseñar la sintaxis del lenguaje que se daba o en cuales botones había que hacer “click” para compilar con netbeans o como generar un reporte con el asistente de Visual Basic xx, otro detalle importante eran los exámenes, a excepción de proyecto final todos los exámenes se hacían en papel y para aprobar bastaba con que el programa “funcione” sin importar la forma de resolverlo.
Acá les dejo el último exámen que rendí, el de Optativa y proyecto final:
Este es el enunciado:

El título dice “Recuperatorio 2do parcial” se ve que fué reutilizado :), bueno acá les dejo mi solución:

class Plancuenta  :Plc_id

  def self.calcular_nro_siguiente cuenta
    Plancuenta.find(:all).select{|p| p.Plc_IdPadre == cuenta}.
      sort{|x,y| x.Plc_NroAux  y.Plc_NroAux}.last.Plc_NroAux + 1
  end

  def self.agrega_plan plc_idpadre, plc_desc
    plc_nroaux = self.calcular_nro_siguiente(plc_idpadre)
    @plan_nuevo = Plancuenta.new( :Plc_IdPadre =>  plc_idpadre,
                                   :Plc_NroAux => plc_nroaux,
                                   :Plc_Desc => plc_desc)
    @plan_nuevo.save
  end

  def self.pone_puntos_intermedios nro
    str = ''
    nro.to_s.each_byte{|b| str += b.chr + "."}
    str
  end

  def self.cuentas_imputables
    ci = Plancuenta.find_by_sql("select * from plancuenta where id NOT IN
                      (select Plc_IdPadre from plancuenta)")
  end

  def before_save
    self.Plc_id = (self.Plc_IdPadre.to_s + self.Plc_NroAux.to_s).to_i
    self.Plc_Cod =  (Plancuenta.pone_puntos_intermedios(self.Plc_id) +
                               self.Plc_NroAux.to_s)
  end

end

class Asientos  :Plc_Id

  def self.hacer_caja
    str = ''
    Plancuenta.cuentas_imputables.each{|c|
      str += "Cuenta: #{c.Plc_id} Saldo: #{Asientos.saldo(c.Plc_id)}\n"
    }
    puts str
  end

  def self.saldo cuenta
     Asientos.find_all_by_Plc_Id(cuenta).collect{|a| a.Asi_Debe}.sum - \
      Asientos.find_all_by_Plc_Id(cuenta).collect{|a| a.Asi_Haber}.sum
  end

end

Esos son los dos modelos que hice para la solución que me llevó 2hs, el código se podría mejorar bastante pero me quedé bastante conforme, recuerden que estaba bajo la presión de rendir un exámen y no tenía mucho tiempo, además el prosefor me entregó la estructura de la base de datos en un archivo .mdb (de MS Access) y como yo uso Linux me la tuve que rebuscar para leer ese archivo y meterlo dentro de una db en Mysql.
Bueno la nota que me saqué fué 9 (sobresaliente).
Que experiencia tuvieron uds. en sus facultades? espero comentarios….

Hace unos días que con Manuel Kaufmann (humitos) venimos comparando algunas cosas entre python y ruby, por simple curiosidad dado que son 2 lenguajes muy parecidos y que nos gustan mucho. Entonces se nos ocurrió escribir algunos problemas puntuales y sencillos para ver como los resuelve cada lenguaje, quiero aclarar que de ninguna manera queremos generar una guerra santa entre lenguajes ni mucho menos simplemente queremos divertirnos comparándolos. Entonces sin más vamos al grano, aquí va mi versión ruby de los ejercicios:

1. Dado un array con nombres de persona eliminar los nombre que comienzan con “Pe”:

   irb(main):005:0> ["Pablo", "Raul",
   "Pedro", "Pepe", "Ariel", "TerePe"].delete_if{|n| n =~ /^Pe/}
   
   =>["Pablo", "Raul", "Ariel", "TerePe"]

2. Verificar si el mismo array contiene el nombre “Raul”

    irb(main):006:0> ["Pablo", "Raul",
   "Pedro", "Pepe", "Ariel", "TerePe"].include?("Raul")
   
   => true

3. Generar un string con todos los nombres unidos por “-”

   irb(main):009:0> ["Pablo", "Raul",
   "Pedro", "Pepe", "Ariel", "TerePe"].join("-")
   
   => "Pablo-Raul-Pedro-Pepe-Ariel-TerePe"

4. Generar un segundo array con los nombres todos en minúsculas ordenado alfabéticamente

   irb(main):012:0> (["Pablo", "Raul",
   "Pedro", "Pepe", "Ariel", "TerePe"].collect{|n| n.downcase}).sort
   
   => ["ariel", "pablo", "pedro", "pepe", "raul", "terepe"]

5. Desordenar el array:

   irb(main):016:0> ["Pablo", "Raul",
   "Pedro", "Pepe", "Ariel", "TerePe"].sort_by{ rand }
   
   => ["TerePe", "Pedro", "Raul", "Pablo", "Pepe", "Ariel"]

6. Averiguar si la lista siguiente tiene números pares:

   irb(main):017:0> [1, 2, 3, 4, 5].any?{|x| x % 2 == 0 }
   
   => true

7. Averiguar si toda la lista son números pares:

   irb(main):018:0> [1, 2, 3, 4, 5].all?{|x| x % 2 == 0 }
   
   => false

8. Obtener el producto de una lista de números:

   irb(main):023:0> [1, 2, 3, 4, 5].inject{|x,n| x * n }
   
   => 120

9. Obtener el factorial de 9999:

   irb(main):025:0> (1..9999).inject{|x,n| x * n }

   No voy a poner la salida del factorial por que es un número muuuuy….. largo pero lo pueden probar por uds mismos en el intérprete interactivo de ruby.

10. Y por último averiguar si dos arrays son iguales:

    irb(main):002:0> [1, 2, 3, 4, 5].eql? [1, 2, 3, 4, 5]
    
    => true

Todos los ejemplos se probaron con la versión 1.9 de ruby. Ahora para ver las versión python vamos a tener que estar atentos al blog de humitos

Mirando algunos videos de rspec y autotest, noté que al correr los tests, en la pantalla de la notebook del video salían unos hermosos mensajes con transparencias, investigando un poco encontré que esto se hace con un programa llamado growl que sólo viene para usuarios de Mac OS X luego de tal desilusión comencé a buscar una alternativa en GNU/Linux … sí! hay un programa llamado aosd_cat que sirve para mostrar mensajes de texto UTF8 en la pantalla, vamos al grano:

apt-get install aosd_cat

Para probarlo podemos abrir una consola y ejecutar:

 echo "Probando..." | aosd_cat   --back-color=black  \
          --fore-color=red \
          --back-opacity=135  --padding=50

Ahora vamos a configurar autotest para que use aosd_cat

editamos el archivo ~/.autotest y ponemos lo siguiente:

module Autotest::Growl
  def self.aosd_cat title, msg, color
    params = "--back-color=black --fade-in=20 --fade-out=100 \
                   --fore-color=#{color} --back-opacity=200 \
                   --padding=30 \  --shadow-offset=0 \
                   --x-offset=0 --y-offset=0"

    system "echo \"#{title} #{msg} \" | aosd_cat #{params}"

  end

  Autotest.add_hook :run do  |at|

    aosd_cat "Autotest running", "Started", "Orange"

  end

  Autotest.add_hook :ran_command do |at|
    results = [at.results].flatten.join("\n")
    output  = results\
    .slice(/(\d+)\s+examples?,\s*(\d+)\s+failures?(,\s*(\d+)\s+pending)?/)
    if output
      if $~[2].to_i > 0
        aosd_cat "FAIL !!!", "#{output}", "red"
      else
        color = output =~ /[1-9]\spending?/ ? "yellow" : "green"
        aosd_cat "Pass", "#{output}", "#{color}"
      end

  end
end

Listo, ya podemos usar autotest y ver los mensajes como en una mac

autotest path-al-proyecto/

Les dejo un screencast para que vean como quedó.

Hace poco tuve que hacer un desarrollo y uno de los requerimientos era hacer un menu (por controller) de acuerdo al rol del usuario, busqué sí ya había un plugin que haga este trabajo pero no encontré nada así me decidí a escribir uno y salió acts_as_menu_role, es algo muy simple, permite “armar” menúes basados en roles.
Aquí les dejo la url del sitio:
http://actsasmenurole.googlecode.com/
y el svn es:
http://actsasmenurole.googlecode.com/svn/tags/acts_as_menu_role
pruébenlo y cualquier cosa acepto sugerencias.

Callbacks y hooks

Para continuar, vamos a ver el tema “callbacks” relacionado con los módulos, los callbacks y los hooks son una técnica de metaprogramación bastante común. Estos métodos son invocados cada vez que ocurre un evento particular durante la ejecución del programa, por ejemplo:

• Un método inexistente es llamado en un objeto
• Una clase es “mixineada” en un módulo
• El “subclaseado” de una clase
• Un método de instancia es agregado a una clase

Atrapando las operaciones de include con Module#included

Cuando un módulo es incluido (Mixed in) dentro de una clase, si se define un método llamado included para ese módulo, entonces este método se ejecuta. El método recibe el nombre de la clase como argumento.

module A
  def self.included(clase)
    puts "He sido incluido en #{clase}."
  end
end

class B
  include A
end

salida:

=> He sido incluido en la clase B.

Usando el callback included para agregar métodos de clase

Podemos atrapar la operación de include para agregar métodos de clase a la clase que estamos incluyendo el módulo:

module A
  def self.included(clase)
    def clase.metodo_de_clase
      puts "Agrego un metodo de clase."
    end
  end

  def metodo_de_instancia
    puts "Agrego un metodo de instancia."
  end

end

class B
  include A
end
b = B.new
b.metodo_de_instancia
B.metodo_de_clase

salida:

=> Agrego un metodo de instancia.
=> Agrego un metodo de clase

Bueno como vemos Module#included es una manera muy útil para agregar cosas a las clases/módulos de nuestros programas.
Esto fue todo, hasta el próximo post.

Nuevamente amigos seguimos con el tema de los módulos en ruby, para continuar comenzaremos con un ejmeplo del uso de “super” entre módulos y clases:

module A
  def imprimir
    puts "Imprimo desde el --modulo-- A"
  end
end

class B
  include A
  def imprimir
    puts "Imprimo desde la --clase-- B"
    puts "Trigger para ejecutar el inmediato mas alto 'imprimir'"
    super
    puts "Vuelvo de la llamada a super."
  end
end
b = B.new
b.imprimir

salida:

=> Imprimo desde la --clase-- B
=> Trigger para ejecutar el inmediato mas alto 'imprimir'
=> Imprimo desde el --modulo-- A
=> Vuelvo de la llamada a super.

La instancia de B (b) recibe el mensaje “imprimir”, como vimos anteriormente comienza mirando la propia clase y encuentra el método “imprimir” , por otro lado dentro del método hay una llamada a super, esto significa que cuando encuentre un método “imprimir” debe continuar buscando hacia arriba al siguiente, la siguiente “ocurrencia” en este caso es la del módulo “A”. Hasta acá todo genial, pero que pasa si el método en cuestión tiene argumentos?
super maneja los argumentos de la siguiente forma:

• Invocado sólo, super automáticamente redirige los argumentos pasado al método desde dónde se invocó.
• Invocado con una lista vacía de argumentos –super()– no envía ningún argumento al método de arriba
• Invocado con una lista de argumentos –super(a,b,c)– este envía exactamente estos argumentos

Cómo siempre cortito y simple, nos vemos en el próximo capítulo