@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

Programa de las jornadas
Cómo llegar a la UEM

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

Para hacerlo, lo primero era descargar la librería Flyin Saucer(que ya viene con iText incluida) y generar la aplicación en Java que se encargase de convertir el documento xhtml en pdf(está copiada casi tal cual de un ejemplo del artículo):

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;

import org.xhtmlrenderer.pdf.ITextRenderer;
import com.lowagie.text.DocumentException;

public class Xhtml2Pdf {

    /**
     * @param args
     */
    public static void main(String[] args) throws IOException, DocumentException {

        if (args.length != 2) return;

        String inputFile = args[0];
        String url = new File(inputFile).toURI().toURL().toString();

        String outputFile = args[1];

        OutputStream os = new FileOutputStream(outputFile);

        ITextRenderer renderer = new ITextRenderer();
        renderer.setDocument(url);
        renderer.layout();
        renderer.createPDF(os);

        os.close();
    }
}

Luego escribí una sencilla función en ruby que se encargase de ejecutar la clase hecha en java pasándole como parámetros el archivo de origen con el documento xhtml y el archivo de destino donde se generaría el pdf(lo único que tiene así de ‘chicha’ es que genera el classpath de manera dinámica):

def xhtml2pdf(input_file, output_file)

  java_dir = File.join(File.expand_path(File.dirname(__FILE__)), "java")
  jar_dir = File.join(java_dir, "jar")

  class_path = ".:#{java_dir}" 

  Dir.foreach(jar_dir) do |jar|
    class_path << ":#{jar_dir}/#{jar}" if jar.match(/\.jar/)  
  end

  command = "java -cp #{class_path} Xhtml2Pdf #{input_file} #{output_file}" 
  system(command)
end

Para poder utilizar la librería desde el controlador, tan sólo quedaba copiar el fichero en ruby dentro la carpeta lib/ del proyecto Rails, la clase en java en lib/java y los jar’s necesarios para ésta, en lib/java/jar:

Y en el controlador tan sólo tenía que generar la vista y guardarla en un fichero, convertirlo en pdf y mandarlo al cliente:

require 'xhtml2pdf'

class FooController < ApplicationController

  def generate_pdf

    @document = Document.find(params[:id])

    xhtml = "/tmp/foo.xhtml" 
    pdf = "/tmp/foo.pdf" 

    File.open(xhtml, "w") do |file|
      file << render_to_string(:template => "pdf/document", :layout => "../pdf/pdf")
    end

    xhtml2pdf(xhtml, pdf)

    send_file pdf,
      :filename => "document.pdf",
      :type => "application/pdf" 
  end
end

Y si quisieramos ir viendo en el navegador cómo va a quedar sin necesidad de generar el pdf, bastaría con comentar el contenido de esta función(o hacer una nueva) y generar la vista como hariamos normalmente:

render :template => "pdf/document", :layout => "../pdf/pdf" 

Por último, comentar que para que Flying Saucer pueda acceder a las imágenes y hojas de estilo del documento xhtml, las rutas de estos elementos deben estar de manera absoluta apuntando a un recurso local(file://<rutadelfichero>) o bien de manera relativa a dónde se encuentre físicamente el xhtml, por lo que igual habría que hacer un helper que modificase la ruta de los recursos dependiendo de si se está previsualizando desde el navegador o se está volcando en disco.

Aunque PDF::Writer parecía funcionar bastante bien e iba más rápido ya que escribe directamente el pdf sin necesidad de parsear un documento xhtml y sus hojas de estilo, creo que en este caso compensa tener un pequeño híbrido en rails y java por el tiempo ahorrado en maquetar el pdf directamente desde ruby.

Document.find(:all, :conditions =&gt; [&quot;visible = ?&quot;, true])<br />Document.find(id, :conditions =&gt; [&quot;visible = ?&quot;, true])<br /><br /># &quot;borrando&quot; el objeto<br />document.visible = false<br />document.save

Esto funcionaba, pero me parecía un tanto engorroso tener que añadir una condición extra a la hora de hacer las búsquedas y borrar en todas las clases que quería que fuesen ‘ocultables’. Así que por aquello de seguir con la filosofía del DRY e indagar un poco en el core de Rails, hice un sencillo plugin que añadía esta funcionalidad de manera transparente y sin necesidad de tocar el código ya existente del controlador. Así, tan sólo habría que marcar la clase del modelo con el método ‘acts_as_invisible’ (Se da por hecho que existe una columna de tipo booleano llamada ‘visible’ en la tabla asociada a la clase):

class Document &lt; ActiveRecord::Base<br />  <br />  acts_as_invisible<br /><br />end

Y a la hora de trabajar con el modelo, se haría de la siguiente manera:

# recuperar s&oacute;lo los documentos visibles<br />Document.find(:all)<br /><br /># recuperar s&oacute;lo los documentos visibles cuyo t&iacute;tulo empiece por 'presupuesto'<br />Document.find(:all, :conditions =&gt; &quot;title like 'presupuesto%'&quot;)<br /><br /># recuperar todos los documentos<br />Document.find(:all, :show_hidden =&gt; true)<br /><br /># ocultar un documento<br />Document.destroy(id)<br /><br /># si se tratase de recuperar el documento ocultado <br /># previamente, saltar&iacute;a una excepci&oacute;n<br />Document.find(id)<br /><br /># volver a hacer visible un documento<br />Document.show(id)<br /><br /># borrar el documento de la base de datos<br />Document.confirm_destroy(id)

Por si a alguien le interesa, puede bajarse el plugin de http://svn.dagi3d.net/rails/acts_as_invisible/tags/acts_as_invisible/ y si tengo algo de tiempo ya le añadiré alguna funcionalidad más como que el nombre del campo utilizado sea configurable.

if current_user.roles.map { |role| role.title }.include?("admin")
...
end

if current_user.has_admin_role?
...
end

module Dagi3d

  module RoleModel
    def self.included(mod)
      mod.extend(ClassMethods)
    end

    module ClassMethods

      def has_roles
        include InstanceMethods
      end

    end # ClassMethods 

    module InstanceMethods

      def method_missing(method, *args)

        if method.to_s =~ /has_(\w+)_role\?/
          self.roles.map {|role| role.title}.include? $1
        else
          super
        end
      end #method_missing

    end #InstanceMethods
  end
end

require 'caboose/logic_parser'
require 'caboose/role_handler'
require 'caboose/access_control'
require 'caboose/role_model'

ActionController::Base.send :include, Caboose
ActionController::Base.send :include, Caboose::AccessControl
ActiveRecord::Base.send :include, Dagi3d::RoleModel

class User < ActiveRecord::Base

  has_roles
  ...
end