Billetes para el tren: aprendiendo a programar con Ruby on Rails (2)

En este post, una vez que ya sabemos lo esencial sobre el lenguaje de programación ruby, vamos a preparar una nueva aplicación Ruby on Rails.

Empezaremos seleccionando los ingredientes necesarios para elaborarla:

Ruby on Rails

Ruby on Rails, es un framework formado por un puñado de módulos ruby y unos cuantos scripts, que nos ofrecen todo lo necesario para construir y configurar nuestra nueva aplicación web.
Por lo tanto, nuestra primera tarea consistirá en instalar el framework. Hay varias formas de instalar Rails en nuestro entorno ruby, la más sencilla y la que mejor resultado da, es instalarlo a través de las ruby gems. Las gemas, como se las llama coloquialmente, es un sistema de distribución de bibliotecas para el lenguaje ruby, al estilo CPAN de perl, que nos permite buscar una biblioteca para realizar una tarea determinada, instalarla fácilmente desde internet y mantenerla actualizadas.

Las gemas se puede descargar desde aquí. La instalación es sencilla, se descarga el fichero rubygems-x.x.x.tgz o rubygems-x.x.x.zip, lo descomprimimos e instalamos el paquete con el código


$ruby setup.rb

La instalación no debería dar ningún problema, pero si apareciese, se puede consultar el manual de instalación de ruby gems en busca de ayuda.

Una vez que estén instaladas las gemas, ya podemos instalar rails usando la siguiente orden:

$gem install rails --include-dependencies --remote


Esta orden instalará rails y todas las otras bibliotecas necesarias para poder usar el framework.

Existen otras posibilidades para instalar el framework, algunos sistemas operativos como FreeBSD o algunas distribuciones de Linux, ofrecen paquetes para rails, puede ser una alternativa viable, pero yo recomiendo usar ruby gems, para evitar problemas de versiones y mantener fácilmente actualizado el framework.

En windows y mac, existen aplicaciones que instalan un entorno con todo lo necesario para utilizar rails, desde ruby hasta un servidor de bases de datos mysql. Estos entornos simplifican en gran medida todo este proceso, pero yo sigo recomendando utilizar el método de las gemas.

Base de datos

Las aplicaciones ruby on rails, utilizan como soporte persistente de datos, un sistema gestor de base de datos relacional. Rails soporta muchos SGBD: postgresql, mysql, oracle... Para esta demo usaremos Mysql, que se puede descargar desde aquí. Bajad e instalad la última versión del SGBD para vuestro entorno.

Entorno de desarrollo

Las aplicaciones rails se pueden programar con el bloc de nota y una shell o ventana cmd.exe, pero existen entornos de desarrollo que hacen más fácil el desarrollo. Una buena elección es RadRails (ahora Aptana), gratuito y construido sobr eclipse. Aunque sin duda alguna, la mejor opción para mi gusto es usar emacs con los modos para ruby y rails.

Creando la aplicación

Una vez descargado e instalado todo lo anterior, estamos listos para empezar a construir nuestra nueva aplicación rails. Para ello abrimos una shell y tecleamos la orden rails seguido del nombre que queremos darle a la aplicación:

 
 $rails test_app
   create  
       create  app/controllers
       create  app/helpers
       create  app/models
       create  app/views/layouts
       create  config/environments
       create  components
       create  db
       create  doc
       create  lib
       create  lib/tasks
       create  log
       create  public/images
       create  public/javascripts
       create  public/stylesheets
       create  script/performance
       create  script/process
       create  test/fixtures
       create  test/functional
       create  test/integration
       create  test/mocks/development
       create  test/mocks/test
       create  test/unit
       create  vendor
       create  vendor/plugins
       create  tmp/sessions
       create  tmp/sockets
       create  tmp/cache
       create  tmp/pids
       create  Rakefile
       create  README
       create  app/controllers/application.rb
       create  app/helpers/application_helper.rb
       create  test/test_helper.rb
       create  config/database.yml
       create  config/routes.rb
       create  public/.htaccess
       create  config/boot.rb
       create  config/environment.rb
       create  config/environments/production.rb
       create  config/environments/development.rb
       create  config/environments/test.rb
       create  script/about
       create  script/breakpointer
       create  script/console
       create  script/destroy
       create  script/generate
       create  script/performance/benchmarker
       create  script/performance/profiler
       create  script/process/reaper
       create  script/process/spawner
       create  script/process/inspector
       create  script/runner
       create  script/server
       create  script/plugin
       create  public/dispatch.rb
       create  public/dispatch.cgi
       create  public/dispatch.fcgi
       create  public/404.html
       create  public/500.html
       create  public/index.html
       create  public/favicon.ico
       create  public/robots.txt
       create  public/images/rails.png
       create  public/javascripts/prototype.js
       create  public/javascripts/effects.js
       create  public/javascripts/dragdrop.js
       create  public/javascripts/controls.js
       create  public/javascripts/application.js
       create  doc/README_FOR_APP
       create  log/server.log
       create  log/production.log
       create  log/development.log
       create  log/test.log
 $
 

Esta orden ejecutará un script que creará el directorio con el nombre de la aplicación que hayamos suministrado y donde incluirá todos los ficheros que forman una aplicación rails.

Estructura de una aplicación Ruby on Rails

Veamos cuales son los principales directorios de una aplicación rails:

• app: aquí está el código de la aplicación propiamente dicha, divido en los subdirectorios para el modelo, controladores y vistas.
• config: configuración de las bases de datos, entorno de ejecución y mapeo de URLs
• scripts: scripts para administrar la aplicación.
• public: contenido estático de la aplicación como imágenes, hojas de estilo CSS, etc.
• test: código de los tests de la aplicación, unitarios, funcionales y de integración.
• db: esquema de la base de datos.
• lib: código auxiliar.
• vendor: plugins y librerias usadas
• tmp: ficheros temporales.
• log: los logs de la aplicación.

Configurando la aplicación rails

Antes de arrancar la aplicación y empezar a desarrollar, hay que configurar la aplicación para que rails pueda conectarse a la base de datos de la misma.

Para ello debemos editar el fichero config/database.yml, veamos un ejemplo:

 # MySQL (default setup).  Versions 4.1 and 5.0 are recommended.
 #
 # Install the MySQL driver:
 #   gem install mysql
 # On MacOS X:
 #   gem install mysql -- --include=/usr/local/lib
 # On Windows:
 #   gem install mysql
 #       Choose the win32 build.
 #       Install MySQL and put its /bin directory on your path.
 #
 # And be sure to use new-style password hashing:
 #   http://dev.mysql.com/doc/refman/5.0/en/old-client.html
 development:
   adapter: mysql
   database: test_app_development
   username: rails
   password: rails_p
   socket: /tmp/mysql.sock
 
 # Warning: The database defined as 'test' will be erased and
 # re-generated from your development database when you run 'rake'.
 # Do not set this db to the same as development or production.
 test:
   adapter: mysql
   database: test_app_test
   username: rails
   password: rails_p
   socket: /tmp/mysql.sock
 
 production:
   adapter: mysql
   database: test_app_production
   username: stradm
   password: dkenew
   socket: /tmp/mysql.sock
 

Rails utiliza tres entornos diferentes para cada aplicación test es el entorno en el que se realizan las pruebas. development es el que estaremos utilizando mientras estemos desarrollando la aplicación y production es el que utilizará la aplicación cuando está esté termianada

Cada etorno utiliza su propia base de datos que hay que configurar en el fichero database.yml, en el aparecen una entrada por cada entorno donde hay que completar los datos para cada uno de ellos, suministrando los datos del SGBD que usamos (en nuestro caso mysql) en la opción adapter, el nombre de la base de datos en database, usuario de la SGBD y password (username y password). Si la base de datos está en un host diferente a localhost, se puede especificar el host con su ip o DNS usando el parametro host.
Para configurar la aplicación debemos rellenar el fichero con las opciones correctas y crear las bases de datos de test, development y production indicadas en mysql con permisos para el usuario y password también especificado.

Arrancando la aplicación

Cuando hayamos terminado de editar databases.yml y hayamos creado las bases de datos, ya podemos poner a funcionar nuestra aplicación rails, arrancando el servidor de aplicaciones. Desde el directorio raíz de la aplicación tecleamos lo siguiente para invocar al script correspondiente:


test_app$ script/server start
=> Booting WEBrick...
=> Rails application started on http://0.0.0.0:3000
=> Ctrl-C to shutdown server; call with --help for options
[2007-08-26 14:18:24] INFO WEBrick 1.3.1
[2007-08-26 14:18:24] INFO ruby 1.8.5 (2006-12-25) [i686-darwin8.8.1]
[2007-08-26 14:18:24] INFO WEBrick::HTTPServer#start: pid=330 port=3000


Si todo es correcto el servidor webrick arrancará nuetra aplicación rails por defecto en el puerto 3000.

Para probar nuestra flamante aplicación abrimos un navegador y buscamos la URL http://localhost:3000, deberíamos ver algo como esto.

Para ver los logs del servidor, se puede abrir el fichero log/development.log en el entorno de desarrollo.

Conclusiones

Al final de este post debemos tener rails instalado y una nueva aplicación creada, configurada y funcionando.
En el próximo post empezaremos a añadir código en la aplicación usando el patrón modelo-vista-controlador que implementa ruby on rails.

servido por Antonio 2 comentarios compártelo