[ruby]
map.resources :messages, :as => ‘mensajes’
# Antes para obtener algo similar hacias esto (y esto no creaba una ruta “RESTful”):
map.connect ‘mensajes/:id/:action’, :controller => ‘messages’
[/ruby]

Esto te permite tener rutas como /mensajes/… en lugar de /messages/… y a la vez aprovechando métodos “RESTful”.

El problema ahora era que tendrias rutas como “/mensajes/new” y “/mensajes/edit”… eso no se ve muy bien.

Pregunte en la lista de Rails Core y me dijeron que podía crear un parche, y es lo que hice, pero ahora necesito que lo prueben y voten por el para que lo incluyan en Rails. Aquí esta el ticket:

“http://dev.rubyonrails.org/ticket/11181″:http://dev.rubyonrails.org/ticket/11181

Si no tienen inconvenientes, agregen un comentario con el texto “+1″.

Bueno, todavía ni he explicado como funciona. Al aplicar el parche, tienes dos opciones para cambiar los nombres de las rutas:

[ruby]
# En environment.rb:
config.action_controller.resources_path_names = { :new => ‘nuevo’, :edit => ‘editar’ }

# En routes.rb:
map.resources :schools, :as => ‘escuelas’, :path_names => { :new => ‘nueva’ }
[/ruby]

Como vez, puedes definir los nombres predeterminados en environment.rb, pero luego puedes sobreescribirlos en tus rutas.

Esto lo dividí en 2 scripts porque si lo hago en uno, en mi máquina no me funciona (kGutsy x64)…

rails_konsole:
[code]
#!/bin/bash
PIDS=`pidof konsole`

konsole –script &

ARGS=”"
for pid in $PIDS; do
ARGS=”${ARGS} -o ${pid}”
done
PID=`pidof ${ARGS} konsole`

sleep 2

application=”Application”
if [ -n “$1″ ]; then
application=”$1″
fi

dcop konsole-${PID} session-1 renameSession $application

dcop konsole-${PID} konsole newSession
dcop konsole-${PID} session-2 renameSession Server

dcop konsole-${PID} konsole newSession
dcop konsole-${PID} session-3 renameSession Console

dcop konsole-${PID} konsole newSession
dcop konsole-${PID} session-4 renameSession AutoTest

rails_konsole_dcops $PID
[/code]

rails_konsole_dcops:
[code]
#!/bin/bash
dcop konsole-${1} konsole activateSession session-1

dcop konsole-${1} session-2 sendSession “ruby script/server”
dcop konsole-${1} session-3 sendSession “ruby script/console”
dcop konsole-${1} session-4 sendSession “autotest -rails”
[/code]

Vaya, se ve horrible y hay un error. Asegúrate de copiar la versión de texto plano y cambiar el guión largo antes de “script” por dos guiones cortos… si ya se, que flojera.

Básicamente lo que hace es que al ejecutar ‘rails_konsole’, te abre una instancia de Konsole con cuatro pestañas, una libre, una ejecutando script/server, otra script/console, y la última para autotest (gem install zentest).

Esto lo ejecutas en el directorio de tu aplicación, y opcionalmente le pasas el nombre de tu aplicación como parámetro (rails_konsole MiApp) para que le de el nombre apropiado a la primer pestaña (para que no te confundas si tienes abiertos varios proyectos).

En fin, les paso una plantilla para NetBeans que sirve para generar una serie de acciones REST estándar. Tu solo necesitas introducir dos variables y el nombre del modelo.

La idea (y práctiamente todo el código) me la robe de “Softies on Rails”:http://www.softiesonrails.com/2007/12/14/textmate-snippet-for-restful-controller.

“Behold”:

[ruby]
def index
@${items} = ${Model}.find :all

respond_to do |format|
format.html # index.html.erb
format.xml { render :xml => @${items} }
end
end

def show
@${item} = ${Model}.find(params[:id])

respond_to do |format|
format.html # show.html.erb
format.xml { render :xml => @${item} }
end
end

def new
@${item} = ${Model}.new

respond_to do |format|
format.html # new.html.erb
format.xml { render :xml => @${item} }
end
end

def edit
@${item} = ${Model}.find(params[:id])
end

def create
@${item} = ${Model}.new(params[:${item}])

respond_to do |format|
if @${item}.save
flash[:notice] = ‘$2 was successfully created.’
format.html { redirect_to(@${item}) }
format.xml { render :xml => @${item}, :status => :created, :location => @${item} }
else
format.html { render :action => “new” }
format.xml { render :xml => @${item}.errors, :status => :unprocessable_entity }
end
end
end

def update
@${item} = ${Model}.find(params[:id])

respond_to do |format|
if @${item}.update_attributes(params[:${item}])
flash[:notice] = ‘${Model} was successfully updated.’
format.html { redirect_to(@${item}) }
format.xml { head :ok }
else
format.html { render :action => “edit” }
format.xml { render :xml => @${item}.errors, :status => :unprocessable_entity }
end
end
end

def destroy
@${item} = ${Model}.find(params[:id])
@${item}.destroy

respond_to do |format|
format.html { redirect_to(admin_${items}_url) }
format.xml { head :ok }
end
end
[/ruby]

Por ahí le falta una arroba (@) en la acción “create”. Sí se la puse, pero ahi arriba no se porque no aparece. Consideralo un acertijo.

Me pareció muy interesante, y se me ocurrió implementarlo para documentar código fuente de Rails.

Creo que este tipo de documentación puede ser muy útil cuando estas desarrollando, o incluso para mostrar un prototipo al cliente, porque puede ver muy fácilmente que esperar que haga la aplicación en cada paso.

Escribí un crudo plugin para hacer esto, y su objetivo es documentar las acciones de los controladores. Espero esta imagen te lo explique mejor:

Ese panel aparece en todas las acciones que tienen documentación definida. En el ejemplo anterior podría ser así:

[ruby]
class SesionesController < ApplicationController
# DD: Validar credenciales de usuario.
def iniciar_sesion
# DD: *Inicio de sesión:*
# # El usuario escribe su login y clave de acceso
# # El usuario da clic en el botón "Iniciar sesión"
# # El sistema válida la información. Si es correcta el usuario es llevado a su cuenta.
hacer_algo_util
# DD: *Errores:*
# p. *El usuario escribe un login incorrecto*
# # Se muestra un error en el campo de login
# DD: *El usuario escribe una clave incorrecta*
# # Se muestra un error en el campo de clave
mas_codigo_rails
etc
end
end
[/ruby]

El panel puedes arrastrarlo por la pantalla, "minimizarlo" (doble clic en el título), o cerrarlo por completo (X).

Escribí el plugin muy rápido, así que esta horrendo. Quiero escuchar opiniones antes de "embellecerlo". Notarán quienes tengan experiencia escribiendo "parsers" que yo no la tengo, así que una ayudadita no caería mal :-)

La instalación no es tan rápida como la de otros plugins, pero de momento creo que es suficiente. Primero baja "este archivo":/wp-content/uploads/2007/08/rd3.tar.gz y descomprimelo en la carpeta vendor/plugins. Dentro de *vendor/plugins/rd3/lib* encontrarás una hoja de estilo. *Copiala a public/stylesheets*.

Luego en el layout de cada controlador (o en el de la aplicación), agrega lo siguiente en la sección *"head"*:

[ruby]
<%= stylesheet_link_tag 'rd3' %>
<%= javascript_include_tag :defaults %>
[/ruby]

Ahora escribe la documentación que quieras para tus controladores con la siguiente guía:

[ruby]
class SesionesController < ApplicationController
# DD: Descripción de la acción.
def iniciar_sesion
# DD: Documentación sobre la acción
# Este comentario es parte del anterior.
codigo
# DD: Otra sección de documentación
# p. *Acepta formato de RedCloth*
# # Esta es una lista
# # Otro elemento
mas_codigo
# Este es un comentario normal que no será incluido
# en la documentación generada.
end
end
[/ruby]

Bien, ya que tienes tu controlador documentado, en la consola ejecutas una tarea de rake:

[code]
rake rd3:update
[/code]

Eso creará unas vistas en *doc/rd3*, que serán las que aparecen en el panel.

Puedes personalizar este panel ya sea con el archivo CSS incluido o editando la plantilla *rd3/lib/panel.erb*.

Ah, casi lo olvidaba, este plugin solo se carga cuando estas en ambiente de desarrollo. En producción por supuesto ya no.

Agradeceré cualquier crítica que me puedan ofrecer :-)

La forma “estándar” de publicar una aplicación Rails (o cualquier otra cosa en realidad), es con “Capistrano”:http://www.capify.org/. Solo es necesario escribir unas “recetas” simples para tu aplicación (que no son más que configuraciones, y algunos comandos, como el servidor a donde se va a publicar, entre otras cosas).

Luego desarrollas tu aplicación como siempre, y cuando quieres probar en un servidor que configuraste, simplemente le das un “cap deploy”, y se hace todo el trabajo por ti.

Algunos desarrolladores creen que Capistrano se esta volviendo muy complejo, y ya no les gusta trabajar con el. No estamos hablando de cualquier equipo de desarrollo, “no”:http://www.rubyhitsquad.com/About_the_Hit_Squad.html.

Este equipo estrella ha creado la máquina de matar “Vlad the Deployer!”:http://www.rubyhitsquad.com/Vlad_the_Deployer.html para asesinar a Capistrano.

Que risa me dio al ver el nombre. Y su página también es muy humorística. Nada más queda ver quien gana la batalla, porque además “no se están metiendo con cualquiera”:http://weblog.jamisbuck.org/.

Shoes es como un framework, pero en vez de desarrollar aplicaciones web, es para aplicaciones de escritorio, con toques de funcionalidad web. Mira esto:

[ruby]Shoes.app do
background “rgb(102, 102, 102)”
stroke 0, 0, 0
x, y = nil, nil
motion do |_x, _y|
if x and y and (x != _x or y != _y)
append do
line x, y, _x, _y
end
end
x, y = _x, _y
end
end
[/ruby]

Esa, es *TODA* la aplicación. Los demás ejemplos de Shoes son igual de simples (y sorprendentes).

Shoes es además el alma de “Hackety Hack”:http://entren.ivanyvenian.com/aprende-ruby-con-hackety-hack/.

Puedes instalar Shoes en Linux, Windows, y Mac OS. Para Linux es así de fácil (y para Mac es muy similar):

* $ wget http://code.whytheluckystiff.net/dist/shoes-0.r117-linux.tar.gz
* $ tar zxf shoes-0.r117-linux.tar.gz
* $ cd shoes-0.r117
* $ ./shoes samples/draw.rb

En Windows:

Muchos clics para bajar y descomprimir el archivo, luego abres un interprete de comandos, te cambias a la carpeta donde lo descomprimiste y ejecutas así “shoes samples\timer.rb” :-)

Esta solo en inglés, y solo para Windows (de momento), pero seguro que a más de uno le podría servir. Para mi hubiera sido una gran diferencia tener un programa así cuando estaba aprendiendo Ruby.

Si sabes inglés, te puede ser muy útil para enseñar a programar a tu hermano menor :)

Yo ya estoy suscrito y para impulsar esto trataré de ayudar a quienes pongan cualquier pregunta en el grupo.

Si tienes algún interés en difundir Ruby en México, no dudes en aportar con preguntas o respuestas.

Para mi es mucho más fácil de leer, y ofrece más espacio para tus feeds.

Tiene varios problemillas menores con algunos colores, pero nada grave.

Necesitas la extensión Stylish para Firefox. Para cualquier otro navegador… suerte :)

“Google Reader Dark OSX”:http://userstyles.org/styles/2948.

Tengo que hacerlo, pero algo que me he dado cuenta es que el desarrollar aplicaciones con Ruby on Rails (y programas/scripts pequeños en Ruby) ha cambiado mi forma de analizar y diseñar código en otros lenguajes.

En el caso de PHP, el código que ahora tengo que escribir es mucho más legible y organizado (dentro de los límites que permite PHP), porqué tan solo ver el horrible código que usualmente se hace con PHP trato de hacer lo posible para que no sea tan desagradable.

Un ejemplo muy claro es WordPress. A pesar de lo popular de la plataforma y de lo “estructurado” que según es, desarrollar un plugin o un tema ni se acerca a algo similar en Ruby. Basta con mirar el código de cualquier plugin o tema para darte cuenta de ello.

Hace poco leí un artículo sobre como el aprender diferentes lenguajes, aunque no los uses, mejora tus habilidades en los que si usas.

“Ben Casnocha”:http://www.casnocha.com/ escribió en su libro “My Startup Life”:http://www.mystartuplife.com/, sobre la utilidad de acoplar el conocimiento común con experiencias no comunes. En este caso yo aplico como “común” lo que normalmente haces.

He leído también varios artículos sobre como tus diferentes hobbies te pueden ayudar en los negocios o tu trabajo. La programación no es la excepción.

Perdón por no dar más referencias, pero no las recuerdo ni las guardé :)