@record.should have_many(:songs) # utiliza la clase Song

@record.should belong_to(:artist) # utiliza la clase Artist­

@record.should have_one(:cover) # utiliza la clase Cover

Si fuese necesario también se puede indicar de manera manual la clase del modelo relacionado:

@record.should have_many(:favorite_songs).from_class(Song)

module ARAssociationsMatchers

  # ARAssociationMatcher
  #
  class ARAssociationMatcher

    def initialize(expected, macro)
      @expected_association = expected
      @expected_macro = macro
    end

    def matches?(target)
      @target = target

      unless @expected_class.nil?
        expected_class = @expected_class
      else
        expected_class_name = @expected_association.to_s.singularize.camelize
        expected_class = Kernel.const_get(expected_class_name)
      end

      reflection = target.class.reflect_on_association(@expected_association)

      !reflection.nil? && (reflection.macro == @expected_macro) && (reflection.klass == expected_class)
    end

    def from_class(expected_class)
      @expected_class = expected_class
      self
    end

    def failure_message
      "expected #{@target.inspect} to #{@expected_macro} #{@expected_association.inspect}, but it didn't" 
    end

    def negative_failure_message
      "expected #{@target.inspect} not to #{@expected_macro} #{@expected_association.inspect}, but it didn't" 
    end

  end

  # matchers functions
  #
  def have_many(expected)
    ARAssociationMatcher.new(expected, :has_many)
  end

  def have_one(expected)
    ARAssociationMatcher.new(expected, :has_one)
  end

  def belong_to(expected)
    ARAssociationMatcher.new(expected, :belongs_to)
  end

end

La idea inicial está tomada de ­este enlace

t.column :price, :precision => 6, :scale => 2, :default => nil

El caso es ­que se  me hacía un tanto repetitivo estar añadiendo la misma línea en todas las migraciones donde me hacía falta(sé que no es para tanto, pero a veces la vagancia me puede) y además no estaba usando el estilo de los nuevos atajos que trae Rails 2.0, así que la solución era tan sencilla como reabrir la clase ActiveRecord::ConnectionAdapters::TableDefinition(bendito Ruby) y crear el método necesario:

class ActiveRecord::ConnectionAdapters::TableDefinition

  def currency(*columns)
    columns.each do |column|
      self.column column, :decimal, :precision => 6, :scale => 2, :default => nil
    end
  end

end­

Y ya podía usar en todas mis migraciones el método t.price teniendo que indicar únicamente el nombre de la columna(o columnas) que quería crear:

class CreateLineItems < ActiveRecord::Migration
  def self.up
    create_table :line_items do |t|
      t.references :order
      t.references :item, :polymorphic => true
      <strong>t.currency :price</strong>
      t.timestamps
    end
  end

  def self.down
    drop_table :line_items
  end
end

Vía all about agile

Programa de las jornadas
Cómo llegar a la UEM

Gracias al consejo del señor Yanes, me animé a probar el servicio que ofrece Google que nos permite utilizar el sistema de correo de Gmail utilizando nuestro propio dominio. Pero lo interesante de esto no es el hecho de poder contar con la interfaz web de Gmail para leer el correo donde queramos(que también podría serlo), si no el poder descargar con nuestro cliente habitual el correo almacenado en los servidores de Google y utilizar su filtro anti-spam que funciona muy bien y así minimizar en la medida de lo posible el coñazo que supone el correo basura. De momento, salvo un falso positivo, me está funcionando mucho mejor que el sistema que lleva Thunderbird integrado que se tragaba unos cuantos correos vende rolex/viagras/hipotecas/titulos falsos, aunque en parte es lógico, porque siempre irá mucho mejor un filtro bayesiano entrenado por 50 millones de usuarios que otro por uno solo…

Google Apps: http://www.google.com/a/

Hace poco salió a la luz vi.sualize.us, un marcador social enfocado a las imágenes que nos permite organizar las fotos que vamos encontrando por internet utilizando etiquetas y compartirlas si queremos. Vamos, que sería el equivalente a del.icio.us  para imágenes y la verdad es que la aplicación tiene bastante buena pinta.

El proyecto ha sido desarrollado en exclusiva por Victor Espigares y también ha contado con la colaboración de ­Sergi Meseguer para la creación de la ­extensión para firefox(todavía en fase beta)

total = mi_array.inject { |sum, obj| sum + obj.value }

pero en este caso no me terminaba de convecer estar llamando al método inject tantas veces como atributos quisiera sumar, así que en teoría la solución pasaría por iterar sobre el array e ir sumando:

var1 = 0
var2 = 0
var3 = 0
...
mi_array.each do |obj|
  var1 += obj.value1
  var2 += obj.value2
  var3 += obj.value3
  ...
end

Funcionar, funcionaba, pero digamos que el código quedaba algo feo, así que para seguir trasteando, intenté encontrar una solución más ‘ruby’ y esto fue lo que hice:

class Array

  def accumulate(fields)

    results = fields.dup

    self.each do |obj|
      fields.each_key do |key|
        results[key] += obj.send(key) if obj.respond_to?(key)
      end
    end

    results
  end
end

Ahora bastaba con llamar al método accumulate sobre el array de objetos e indicar qué atributos quería sumar para obtener un hash con los resultados:

# la lista de objetos
foos = [
  OpenStruct.new(:foo => 1, :bar => 2, :foobar => 3),
  OpenStruct.new(:foo => 3, :bar => 4, :foobar => 5),
  OpenStruct.new(:foo => 5, :bar => 6, :foobar => 7)
]

foos.accumulate(:foo =>­; 0, :bar => 0, :foobar => 0) 
# {:foo=>9, :bar=>12, :foobar=>15}­

Y esta fue la solución a la que llegué (de momento no hace ningún control sobre las versiones, pero si tengo un rato intentaré completarla):

task :compare_gems do

  def parse_gem_line(line, gems)
    if line =~ /^([[:alnum:]]+)\s\((.*)\)/
      gem = $1
      gems[gem] = []
      versions = $2.gsub(/\s/, '').split(",")
      gems[gem] << versions
    end
  end

  local_gems = {}
  remote_gems = {}

  local_gem_list = %x{gem list}
  local_gem_list.each_line { |line| parse_gem_line(line, local_gems)}

  run "gem list" do |channel, stream, data|
    parse_gem_line(data, remote_gems)
  end

  not_installed_gems = local_gems.dup

  not_installed_gems.delete_if {|key, value| remote_gems.has_key? key }

  puts "== Not installed gems ==" 

  not_installed_gems.each_key do |gem|

    puts "* #{gem}" 
    puts "Install? [yN]" 
    answer = STDIN.gets.chomp

    if answer.downcase == "y" 
      run "gem install #{gem} -y" do |channel, stream, data|
        puts data
        if data =~ /^>/
          install_option = STDIN.gets.chomp
          channel.send_data "#{install_option}\n" 
        end
      end
    end
  end

  puts "========================" 
end