# Make sure all inboxes are empty.
def process (inboxes)
  inboxes.each { |inbox|
    inbox.each { |item|
      if item.requires_action? then
        if item.takes_epsilon_time? then
          item.do()
        elsif item.can_be_delegated? then
          item.delegate
          waiting_for.append(item)
        else
          deferred.append(item)
        end
      elsif item.is_needed_later? then
        filing_system.append(item)
      elsif item.maybe_wanted_later?
        someday_maybe.append(item)
      else
        trash.append(time)
      end
    }
  }
end

Taked from http://paste.ubuntu.com/263929/ and translated to Ruby language.

O aplicativo Fantasdic é un aplicativo de diccionario que permite buscar palabras dende moitas e diversas fontes. Destinado principalmente ao escritorio de GNOME, pero tamén pode traballar en outras plataformas, incluso en Windows. Fantasdic é software libre e programado na linguaxe de programación Ruby.

A principal vantaxa que presenta é o sistema de complementos, o que permite de forma sinxela extender o programa para que poida “consumir” datos dende as fontes que desexemos. O único necesario é programar o complemento axeitado.

Podedes obter a tradución ao galego dende: http://l10n.gnome.org/vertimus/fantasdic/master/po/gl

Aquí explicarei como instalar os dous complementos que programei para estender o aplicativo e así permitir que poida consumir datos dende http://open-tran.eu e máis do Corpus de Mancomun (www.mancomun.org).

Read the rest of this entry »

Continuamos con el procesado de documentos XML con Ruby pero esta vez vamos a utilizar otro parser proporcionado en REXML.

La plase StreamParser delega la gestión de nodos en un XML a una clase definida por el usuario, la clase non será más que un Listener que implementa unas funciones predefinidas. Otra de las ventajas que ofrece StreamParser es que no hace falta cargar el flujo XML de forma íntegra en memoria, haciéndolo especialmente aconsejable para tratamientos de flujos XML muy grandes o para entornos con pocos recursos, el análisis de este flujo se hace de forma progresiva. La desventaja principal es que tenemos que asegurarnos que el flujo XML de entrada es válido ya que StreamParser no lo gestiona, en caso contrario el Listener no funcionará correctamente.

Con un poco de metaprogramación podemos analizar como funciona un parser de flujos XML, para ello aprovechamos la método method_missing que es llamado cada vez que un método no está definido dentro de un módulo o clase, de esta forma podemos hacer lo siguiente:

require "net/http"
require "rexml/document"
include REXML

class NovasListener
  def method_missing(method_id, *args)
    puts "El método #{method_id.id2name} fue llamado"
  end
end

Document.parse_stream(
  Net::HTTP.get("www.mabishu.com", "/blog/feed/rss/"),
  NovasListener.new
)

Read the rest of this entry »

Uno de los problemas al lidiar con documentos XML es el análisis de los mismos y la representación del resultado en nuestros programas. Actualmente hai dos formas de análisis de esquemas: el análisis en árbol (tree parsing) y el análisis de flujos (stream parsing). En este artículo tratare el primer caso utilizando una de las librerías estándar de Ruby llamada REXML.
Un analizador en árbol lee el documento XML completo y represente su árbol en memoria.

La forma más sencilla de convertir un documento XML en un árbol no prodría ser más fácil.

require "rexml/document"
include REXML

doc = Document.new("<verdad-verdadera>Ya llega el veranito</verdad-verdadera>")
print doc.root.name, ": ", doc.root.text, "\n"

Esto produce:

verdad-verdadera: Ya llega el veranito

Al llamar Document.new() con este ejemplo estamos convirtiendo una cadena de texto en una instancia de la clase Document, pero el metodo new() acepta parámetros de distintos tipos:

• Las instancias de la clase REXML::Document simplemente se copiarán
• Las cadenas que contienen documentos XML se analizarán y serán convertidas en instancias de la clase REXML::Document.
• Las instancias de la clase IO serán leídas y analizadas. Por ejemplo para analizar un fichero llamado ejemplo.xml, deberías llamar a:

Document.new(File.new("ejemplo.xml"))

Para acceder a los elementos o atributos de un nodo existen un par de funciones que nos va a ser de mucha ayuda:

• .elements es una función que nos devuelve un array con los elementos hijo que contiene un nodo. por lo que podemos iterar sobre ellos.

document.root.elements.each do |hijo|
	puts hijo.text
end

• .attributes es una función que nos devuelve un hash con los atributos y sus valores correspondientes al elemento desde el que se llama.
• .text si el elemento a analizar es un nodo con texto o con texto y más elementos hijos podemos extraer sólo la parte plana con esta función.

Hay que tener en cuenta que los índices de los elementos REXML comienzan por 1, y no por 0, por lo que para recoger el primer hijo del elemento raíz deberías llamar a document.root.elements[1] o tambien documento.root[0] (nótese que en este caso si que es 0).

Teneis mucha más documentación en http://www.ruby-doc.org/core/classes/REXML.html