Creando un Módulo con Modelo, Controlador y Vista

Planeando nuestro modelo

Hemos mencionado que lo que queremos hacer en este curso es escribir una libreta de direcciones. Así que comenzaremos a planear nuestro modelo.

Información Diferentes Maneras de crear un Modelo

Hay tres maneras de crear un modelo en un sistema:

Pantallas: No es muy recomendable, pero puede uno basarse en un boceto de las pantallas.
Modelo de Objetos: Si usted está acostumbrado a utilizar Java y/o a hacer programas que no utilicen bases de datos, puede ser que usted utilice un modelo de classes y objetos.
Modelo de base de datos: Si usted crea muchas aplicaciones de bases de datos (o es administrador de bases de datos), usted probablemente crea su modelo de base de datos primero.

El modelo de rails es una combinación de modelo de base de datos y modelo de objetos. En el paradigma de diseño típico, usted modela las tablas y relaciones de bases de datos y después crea el código del modelo. Ésta es la manera recomendable de diseñar el programa.

Creando la tabla en la base de datos.

La mejor manera de crear la tabla es utilizando una migración. Una migración es un concepto de ActiveRecord que le permite mantener las modificaciones al esquema de su base de datos sincronizadas con la version actual de su código. Para crear una migración, usted debe hacer lo siguiente:

$ cd direcciones
$ ruby script/generate migration crea_tabla_personas
     create  db/migrate
     create  db/migrate/20081102001338_crea_tabla_personas.rb

Rails ahora ha creado una clase llamada CreaTablaPersonas (en el archivo db/migrate/20081102001338_crea_tabla_personas.rb, que contiene los métodos self.up y self.down:

class CreaTablaPersonas < ActiveRecord::Migration
  def self.up
  end

  def self.down
  end
end

Una migración define los métodos self.up y self.down para hacer y deshacer respectivamente sus cambios al esquema. Para crear nuestra tabla, definimos la tabla con un comando de ruby en self.up. También escribiremos el código para deshacer nuestros cambios (en este caso, eliminar la tabla) en self.down:

class CreaTablaPersonas < ActiveRecord::Migration
  def self.up
    create_table :personas do |tabla|
      tabla.string :nombre, :limit => 80, :null => false
      tabla.string :apellido_paterno, :limit => 80
      tabla.string :apellido_materno, :limit => 80
      # El nombre que debemos desplegar en pantalla
      tabla.string :desplegar, :limit => 80
      tabla.string :sexo, :limit => 10, :default => 'Hombre', :null => false
      tabla.text :notas
    end
  end

  def self.down
    drop_table :personas
  end
end

El resultado de ejecutar la migración será el siguiente SQL (en mysql):

CREATE TABLE personas (
 id int NOT NULL auto_increment,
 nombre varchar(80) default NOT NULL,
 apellido_paterno varchar(80) default NULL,
 apellido_materno varchar(80) default NULL,
 desplegar varchar(80) default NULL,
 sexo varchar(10) default 'Hombre',
 notas TEXT NULL,
 PRIMARY KEY (id)
);

Note que el campo identificador (id) se crea automáticamente.

Cuando su código esté listo, simplemente ejecute el comando:

$ rake db:migrate

Y el sistema se conectará a la base de datos y ejecutará la migración.

Rails mantiene una tabla en la base de datos llamada schema_info que contiene la "versión" actual de la base de datos. Si usted ejecuta el comando rake migrate VERSION=x, la base de datos cambiará a la versión X, ya sea ejecutando los métodos "up" de las migraciones que no se han hecho, o ejecutando los métodos "down" de las versiones que hay que revertir.

Migraciones Irreversibles

De vez en cuando usted necesitará hacer una migración irreversible (por ejemplo, si necesita eliminar una columna de la base de datos). Cuando esto ocurra, ¡no deje self.down vacío! Utilice "raise IrreversibleMigration" para que el sistema sepa que los cambios en self.up son irreversibles.

Creando un Andamio

Ahora que tenemos nuestro modelo en la base de datos, podemos decirle a rails que cree nuestro modelo, controlador y vista con un sólo comando, ejecutando el programa generate con el nombre de nuestra tabla en MySQL:

$ ruby script/generate scaffold persona
 exists app/models/
 exists test/unit/
 exists test/fixtures/
 create app/models/persona.rb
 create test/unit/persona_test.rb
 create test/fixtures/personas.yml
...

Para ver como se creó el modelo, veamos el código de persona.rb:

class Personas < ActiveRecord::Base
end

Es algo que puede escribir usted mismo, pero usar los generadores le ahorra tiempo y evita errores.

¿Y las propiedades?

Notará que su clase Personas no tiene propiedades equivalentes a los campos de la base de datos. Esto es porque Ruby automáticamete crea propiedades para los campos de la tabla de Personas en la base de datos. Recuerde, Ruby utiliza el principio "No te Repitas".

Esto es muy útil, especialmente porque cuando estamos comenzando en nuestro proyecto muchas veces tenemos que cambiar los nombres de los campos hasta que los prototipos y el código se estabilice.

El generador ha creado lo que llamamos un andamiaje (scaffolding).

¿Andamio? ¡Si no soy albañil!

En construcción, un andamio (scaffold) es una construcción muy sencilla que hace posible la construcción del edificio real. De la misma manera, un el generador crea una construcción sencilla en Rails que nos permite añadir registros a la base de datos de inmediato, y nos sirve de andamiaje, haciendo posible construir el programa real.

Ahora podemos comenzar nuestro servidor y navegar a http://127.0.0.1:3000/personas para ver nuestro andamio y crear algunos registros de prueba.

Como verá su andamio contiene un listado, vista, actualización, y borrado de registros. Esto es lo que le llaman en inglés "CRUD", por las siglas de "create/replace/update/delete". Su listado también le muestra páginas. Trate de añadir más de diez registros para verlo funcionar.

Singular/Plural: Note que el estándar de Rails es utilizar plural para los nombres de las tablas en la base de datos (create table personas), y singular para ejecutar los generadores. El generador pluralizará el nombre cuando lo considere adecuado.

Rails pluralizó automáticamente el nombre "persona" que le dimos al generador. La estructura plural/singular queda como sigue:

Tabla (en Base de Datos)	PERSONAS	Plural
Modelo (en app/models)	persona.rb	Singular
Vista (en app/views)	personas/*.rhtml	Plural
Controlador (en app/controllers)	pesonas_controller.rb	Plural
Prueba (en tests/functional)	personas_controller_test.rb	Plural

La idea de la regla es que la única mención de singular es cuando creamos el modelo.

Si esto no es adecuado a su proyecto, usted puede cambiar algunas de estas reglas cambiando el archivo config/environment.rb. Algunos de los cambios que le interestarán son:

ActiveRecord::Base.pluralize_table_names (true/false) le permite decirle a rails que pluralize o no los nombres de las tablas. Si su administrador de base de datos no quiere que las tablas estén en plural, escriba ActiveRecord::Base.pluralize_table_names = false.
ActiveRecord::Base.primary_key_prefix_type (:table_name/:table_name_with_underscore) le permite definir la manera en que ActiveRecord calculará el campo identificador por defecto. En nuestro ejemplo, con el valor :table_name el campo identificador sería personaid, pero con la opción :table_name_with_underscore el campo identificador sería persona_id.

El Inflector

ActiveRecord utiliza una clase llamada Inflector para especificar las reglas de pluralización. Usted puede modificar y añadir nuevas reglas de pluralización para su aplicación también con config/environment.rb. Simplemente agregue otras reglas utilizando expresiones regulares para definir inflecciones del plural, singular, irregular, o imposible de contar (no tiene plural) como sigue:

Inflector.inflections do |inflect|
  inflect.plural /^(ox)$/i, '\1en'
  inflect.singular /^(ox)en/i, '\1'
  inflect.irregular 'person', 'people'
  inflect.uncountable %w( fish sheep )
end

Pero mi Administrador de Base de Datos es muy Estricto....

Si su administrador de DB es muy estricto (o la base de datos pertenece a otro programa y no se puede cambiar), usted puede cambiar el nombre de la base de datos en el modelo persona.rb cambiando el método table_name. Por ejemplo, trabajamos en un banco enorme y tienen estándares de esos que obligan a utilizar nombres ilegibles (pobrecitos!) de sólo ocho caracteres para que sean compatibles con su computadora mainframe de 1970 (ouch!), y el nombre de la tabla de persona debe ser "DC_PERSN":

class Personas < ActiveRecord::Base
  def self.table_name() "DC_PERSN" end
end

Listo!