Bulk updating Gem source index for: http://gems.rubyforge.org/
 

La "amable" respuesta del equipo de soporte de slicehost: "mira en el foro", algo que había hecho a conciencia sin que ninguna de las propuestas funcionara. (Borrar source_cache, matar procesos zombies... etc.).

Manuel me recomendó que para situaciones hiciera la instalación local descargando las gemas directamente en el servidor.

Y estas son las que necesité para Rails 2.0:

1. Activesupport
2. Actionpack
3. Actionmailer
4. Activerecord
5. Actionwebservice
6. Activeresource
7. Rake
8. Rails

Créate una carpeta "sources", y dentro de ella descarga con wget cada una de las gemas por el orden que aparece en la lista. La descarga directa es mucho más rápida. Por ejemplo:

 wget http://rubyforge.org/frs/download.php/37753/activesupport-2.1.0.gem
 

Una vez las tengas todas, ejecuta el comando gem con el parámetro -l, que quiere decir que se instalará sin acudir al repositorio de gemas.

 gem install  -l
 

Una vez instalado Rails, aparentemente las gemas causantes de este cuelgue, pude instalar las gemas de mongrel y mongrel_cluster y probar gem update con toda normalidad.

Qué paciencia...

 => Booting Mongrel (use 'script/server webrick' to force WEBrick) 
 => Rails 2.1.0 application starting on http://0.0.0.0:3000 
 => Call with -d to detach 
 => Ctrl-C to shutdown server 
 ** Starting Mongrel listening at 0.0.0.0:3000 
 ** Starting Rails with development environment... 
 Exiting 
 /usr/local/lib/ruby/gems/1.8/gems/rails-2.1.0/lib/initializer.rb:225:in 
 `require_frameworks': no such file to load -- openssl (RuntimeError) 
 

Una de las soluciones posibles es instalar (o reinstalar) libopenssl-ruby con el comando siguiente.

 sudo apt-get install libopenssl-ruby 
 

A mí me ha funcionado!

Si estás acostumbrado a trabajar con MySQL, mediante el parámetro "-d mysql", puedes saltarte la versión por defecto tomar como base de datos MySQL.

 rails mi-aplicacion -d mysql
 

Fuente: Rails 2.0.2: Some new defaults and a few fixes

Esta información es necesaria en la primera línea de los scripts o shebang, que es aquella que llamará a los ejecutables de Ruby.

¿Qué significa esto? Que para ejecutar scripts en Ruby deberías cambiar la primera línea de tus scripts para acomodarlo al entorno en el que vaya a funcionar la aplicación.

Solución

Mediante el parámetro "--ruby /ruta/a/ruby" puedes generar las aplicaciones con el shebang que introduzcas en el parámetro. En este caso, tras averiguar la ruta hacia Ruby el servidor de producción:

puedes predeterminar el shebang de una aplicación para que cuadre con la ruta en producción, mediante el parámetro --ruby

El shebang resultante sería:

Si el enlace a tu máquina de desarrollo no tiene acceso a Ruby en esa ubicación, puedes, mediante un enlace simbólico (symlink) crear un vínculo entre las rutas de tu entorno de desarrollo y la que has definido para producción en el paso anterior. De esta manera, la aplicación funcionaría en ambos entornos sin tener que tocar el shebang.

 # Enlazar la ubicación de Ruby en desarrollo con un symlink
 local$ sudo ln -s /opt/local/bin/ruby /usr/local/bin/ruby 
 local$ sudo ln -s /opt/local/bin/ruby /usr/bin/ruby 
 

Fuente: Deploying Rails Applications. A step by step guide. Ezra Zygmuntowicz

El caso es que ya es oficial:
Capgemini Dinamarca usa Ruby On Rails como herramienta de prototipado y en algunos casos en producción.

Razones: mayor productividad, menor coste y mejoras notables en la calidad del producto final. Tal y como lo cuentan parece ser la piedra filosofal del software.

We have had working prototypes up and running in a matter of hours. A specific example was a project we decided to implement in Ruby on Rails. Originally the project was estimated at 400 hours in Microsoft .Net. With Ruby on Rails we could deliver it in 110 hours.
-- Jesper Rønn-Jensen

Watch live video from HackerTV on Justin.tv

• Has creado tu aplicación mediante el comando Rails (rails miapp --database=mysql). Es importante que especifiques el tipo de base de datos que quieres emplear, ya que en caso contrario, por defecto puede tomar SQLite.
• Has creado la base de datos de desarrollo: con el comando mysqladmin -u root miapp_development.
• Has configurado el archivo config/database.yml para conectar con la base de datos de desarrollo.

Para comprobar que todo funciona correctamente, acude al shell e introduce el comando:

rake db:migrate

Si el sistema muestra el siguiente mensaje de error:

/usr/local/bin/rake:17: undefined method `require_gem' for main:Object (NoMethodError)

Es porque la versión de rake en nuestro sistema está desactualizada. Para actualizarla, y desde el shell, debemos introducir el siguiente comando.

sudo gem install --remote rake

Vuelve a introducir rake db:migrate y el mensaje de error habrá desaparecido.

The Complete Guide to Rails Plugins: Part I

The Complete Guide to Rails Plugins: Part II

Plugins Howto

Making a Plugin (video)

rake: sin parámetros reconstruye la base de datos de testing utilizando las migraciones y ejecuta todos los tests en el directorio test.

rake db:migrate: actualiza la base de datos. Con el parámetro VERSION=X, después del comando, la actualiza a la versión especificada, por ejemplo, rake db:migrate VERSION=3.

rake db:test:clone: copia la base de datos de desarrollo en la de testing para ejecutar los tests.

rake stats: muestra las estadísticas de nuestra aplicación.

 +----------------------+-------+-------+---------+---------+-----+-------+
 | Name                 | Lines |   LOC | Classes | Methods | M/C | LOC/M |
 +----------------------+-------+-------+---------+---------+-----+-------+
 | Controllers          |     7 |     3 |       1 |       0 |   0 |     0 |
 | Helpers              |     3 |     2 |       0 |       0 |   0 |     0 |
 | Models               |    44 |    27 |       4 |       1 |   0 |    25 |
 | Libraries            |     0 |     0 |       0 |       0 |   0 |     0 |
 | Components           |     0 |     0 |       0 |       0 |   0 |     0 |
 | Integration tests    |     0 |     0 |       0 |       0 |   0 |     0 |
 | Functional tests     |     0 |     0 |       0 |       0 |   0 |     0 |
 | Unit tests           |    82 |    63 |       4 |       6 |   1 |     8 |
 +----------------------+-------+-------+---------+---------+-----+-------+
 | Total                |   136 |    95 |       9 |       7 |   0 |    11 |
 +----------------------+-------+-------+---------+---------+-----+-------+
   Code LOC: 32     Test LOC: 63     Code to Test Ratio: 1:2.0
 

rake doc:app: genera la documentación del proyecto basándose en RDoc (Lectura recomendada: Introducing RDoc ).

rake db:sessions:create: crea una tabla para almacenar sesiones de usuario mediate cookies. Útil para sistemas con autenticación.

rake db:sessions:clear: Cada sesión de usuario crea una nueva fila en la tabla de sesiones, por lo que es importante realizar limpiezas periódicas. Este comando vacía la tabla de sesiones.

rake log:clear: limpia los archivos de log de la aplicación. Conviene ejecutarlo periódicamente para evitar que los archivos ocupen demasiado espacio.

rake rails:freeze:gems: importante si queremos mantener nuestra aplicación "congelada", es decir, utilizar la versión de Rails que tenemos instalada actualmente en el sistema de manera que una actualización inesperada incompatible no rompa nuestro trabajo.

rake rails:unfreeze: descongela la aplicación abriéndola a actualizaciones.

rake rails:freeze:edge: para valientes. Copia el último código disponible del repositorio subversion de Rails -posiblemente inestable- y lo almacena en el directorio vendor/rails de la aplicación.

Fuentes: Ruby On Rails, Beginning Ruby On Rails for eCommerce Appress, 2006, Martin Fowler

Ahora me toca con ZenTest y Autotest, como he leido en este antiguo post de Geoffrey Grosenbach.

La idea es que el proceso de testing se acelera, si al menos es por dejar de mirar al navegador, ya estamos ganando algo. :-)

Si no tienes videntes en tu equipo, échale un vistazo a este video de 28 minutos en el que Gregg Pollack te dejará claro porqué Rails es ideal para proyectos web.

Fuente Rails Envy

De momento, son sólo unas líneas de código en mi máquina, pero cuando salga al éter y se haga famosa, habra un par de cosas que agradeceré: el haber hecho tests y saber cosas del arte del cacheo.

Este es un tutorial imprescindible sobre cacheo en Rails: Ruby On Rails Caching Tutorial.

Visto en Amber Mac.

Si le pegas al asunto de los microformatos , seguro que te vendrá bien mofo, un plugin para Rails de "parseo" de microformatos basada en Hpricot , el parseador de HTML desarrollado en Ruby por ese enigmático personaje: Why The Lucky Stiff.

Más sobre mofo y microformatos

• microformatos Rails y La Coctelera (Fernando Blat).

Me and uformats

• Mofo - Parse Microformats with Ruby (Snippet)
• Intercepting microformats in Rails

Acabo de descubrir Monkey Test.

Es una gema que puedes instalar en tu máquina y sirve para mostrar el output de tus baterías de tests de forma más ordenada y en color (el clásico rojo/verde).

Para instalar la gema de Monkey Test, si estás en Mac OS X o en Linux, desde tu consola debes teclear: sudo gem install monkeytest. Selecciona el número de tipo de instalación y ya lo tienes.

Si ya has escrito tus primeros tests puedes probarla. Para ejecutarla, desde el directorio raíz de tu aplicación y teclea monkeytest. Obtendrás una resultado similar a esta captura: una tabla y el resultado de cada test (PASS, FAIL, ERROR) en color.

Más visual y atractivo. ¿No?

Monkey Test

Tengo una teoría: todo profesional del código -sea frontend, backend-, con la suficiente dosis de presión, ñapeará su código, independientemente del punto de partida rompiendo las convenciones.

De Rails me resulta fascinante la idea de que, en un framework con cierta complejidad, se hayan creado convenciones coherentes. Si ya hay problemas, desacuerdos y cierto caos cuando estás creando una plantilla sencilla de HTML o una CSS, imagínate la tendencia al caos que puede tener desarrollar un framework por "muy bello" que pueda resultar Ruby .

De hecho... así son las cosas: tienes un framework limpito y ordenado como punto de partida sobre el que vas desarrollando, y poco a poco te das cuenta de que pierdes el criterio a la hora de nombrar métodos, componentes, etc.

Ese es el poder de las convenciones: tener las cosas claras y empezar en pequeñito, o sino, échale un vistazo a los microformatos. (Si te suenan pero no sabes lo que son lee aquí: Microformatos. La Web Semántica para Torpes )

Cambios en Rails 2.0

Nada dura para siempre, y la versión de Rails 2.0 va a eliminar antiguas maneras de trabajar para crear convenciones más coherentes con lo desarrollado hasta ahora.

Así, trabajando en la consola van apareciendo los famosos "DEPRECATION WARNING", o avisos de código que no será soportado en el futuro como es el caso de la etiqueta del helper end_form_tag: DEPRECATION WARNING: end_form_tag is deprecated and will be removed from Rails 2.0 See http://www.rubyonrails.org/deprecation for details.

No es el único cambio. Hazles caso y échale un vistazo a Rails 2.0 Deprecation.

maquina:~ maquina$ mysql

Esto es lo que vemos:

 mysql> show databases;
 +--------------------+
 | Database |
 +--------------------+
 | information_schema | 
 | test | 
 +--------------------+
 2 rows in set (0.00 sec)
 

¿Dónde están nuestras bases de datos? ¿Porqué no aparecen? La respuesta es que posiblemente hayas accedido como un usuario anónimo y este perfil tiene el acceso limitado.

Compruébalo tecleando:

 mysql> SELECT user(), current_user();
 +---------------------+----------------+
 | user()              | current_user() |
 +---------------------+----------------+
 | yo@localhost | @localhost     | 
 +---------------------+----------------+
 1 row in set (0.26 sec)

Sal de MySQL y vuelve a entrar poniendo el parámetro -uroot

maquina:~ maquina$ mysql -uroot

Ahora el comando mysql> show databases; debería mostrarte las bases de datos que estabas buscando. Vaya susto, ¿eh?

A éste método, se le denomina "scaffolding" y sirve para implantar de manera inmediata un entorno de administración temporal sobre el que trabajar. El scaffold o andamio generalmente es removido de la aplicación y sustituido por métodos propios en el controlador.

Tipos de scaffolding

Con Rails se pueden crear dos tipos de andamiajes:

Dinámico: se generan en la memoria de la máquina y no permiten la "customización" de la apariencia. Toman directamente los datos de la tabla y los presentana través de un interfaz básico.

Se crea introduciendo el siguiente código en el controlador.

Código: scaffold :nombre_modelo

Estáticos: mediante este "scaffolding" se generan todas las vistas necesarias para la administración del sistema. Es decir, se crean los archivos rhtml necesarios para la presentación de las vistas en la carpeta app>views

Comando: ruby/script generate scaffold product admin

Mediante este comando se generarán los directorios y archivos necesarios correspondientes a los métodos de CRUD alrededor del modelo Product en el controlador admin.

Uno de los asuntos que "preocupan" del scaffolding es la apariencia,por lo que se han desarrollado versiones más sofistcadas que hagan interfaces más atractivos y avanzados, incluso con AJAX de serie !

Más sobre el "andamiaje" de aplicaciones:

Tutorial sobre Scaffolding