- Empezamos tocando el config/routes.rb :

– Comentamos map.resources :posts <– Para que no se pueda acceder por las url “clasicas” de post
– Editamos map.resources :blogs, :has_many => :posts <– Para que se pueda acceder por las url tipo REST de post a traves de Blog

- Ahora vamos al controlador de posts :

– En todos los metodos del controlador buscamos el blog: @blog = Blog.find(params[:blog_id]) <– Necesitamos el blog en todas las acciones de post puesto que luego lo vamos a usar en las vistas.
– Editamos los redirect to @post por redirect_to(blog_posts_path(@blog)) <– no queremos redirigir a mostrar los posts, sino a los posts del blog

- Cambiamos los formularios de edicion y creacion:

– Pasaran a ser: form_for ([@blog, @post]) do |f|

– Por ultimo editamos las vistas para cambiar los links que hagan referencia a los posts:

– Los links ATRAS(listar) son : link_to “Atras”, blog_posts_path(@blog)
– Los links a EDITAR son: link_to “Editar”, [:edit, @blog,@post]
– Los links a MOSTRAR son: link_to “Mostrar”, [@blog,post] <— ojo, post sin @ cuando lo tenemos dentro de un bucle… (ej el index que genera el scaffold), en el edit del scaffold seria con @

– Los links a NUEVO son: link_to “Nuevo”, new_blog_post_path(@blog)

– Los links a Borrar son: link_to ‘Borrar’, [@blog,post], :confirm => ‘Are you sure?’, :method => :delete

Es una guia rapida y chapucera, pero para orientarnos un poco valdra no?

• Arrancar el servidor: NO se debe utilizar nunca el servidor de Aptana, sino que se debe arrancar desde la consola: ruby script/server -p nPuerto. La parte de especificación del puerto es opcional. Si se omite, se tomará el puerto 3000.
• Generar un controlador: ruby script/generate controller nombre_controlador accion1 accion2 … accionN. Las acciones son los métodos que contendrá el controlador, aunque se pueden omitir. En este caso, se creará un controlador vacío.
• Generar un archivo de migración: ruby script/generate migration nombre. No hay que incluir el número de orden de la migración, pues el sistema se encarga de ello.
• Ejecutar migración: rake db:migrate -VERSION=versión. Para ejecutar una migración concreta. Si no se especifica la versión, ejecutará la última migración.

app

Esta carpeta contiene los archivos que forman el sitio, repartidos según sus características en los subdirectorios controllers, helpers, models y views.

• Models: la función principal de los modelos es la obtención de datos, almacenados en una base de datos, un fichero, etc., y de controlar la integridad de estos datos.
• Views: en una página web, las vistas son las distintas interfaces del usuario. A su vez, contiene una carpeta denominada Layout. Aquí, están unos ficheros que incluyen, básicamente, el apartado head de un archivo html. Después, por medio de bloques Ruby, se añade el cuerpo de las vistas para conformar el fichero completo.
• Controllers guarda los archivos correspondientes a los controladores del sistema. Su trabajo consiste en recibir eventos del usuario (envío de formulario, pulsación de un enlace), invocar al modelo para recuperar los datos que necesita, y trasladarlos a la vista, para que los muestre.

Cuando se definen las acciones de un controlador, se debe crear una vista para cada una de estas acciones. Cuando se invocan estos métodos, tras su ejecución, se muestra automáticamente la vista correspondiente al método ejecutado. A su vez, si es necesario, se puede crear un modelo para el controlador.

config

En esta carpeta, se almacenan los archivos de configuración del proyecto. Los archivos que nosotros solemos modificar son routes.rb y database.yml. En el primero, es posible modificar el controlador y su acción que se ejecutarán al acceder al sitio. En el otro, podemos modificar el nombre de la base de datos asociada al proyecto.

db

Principalmente, esta carpeta incluye las migraciones, es decir, los archivos de creacion y edición de la base de datos relacionada con el proyecto.

doc

Aquí se almacena la documentación del proyecto.

log

Los archivos guardados en este directorio son registros de la ejecución del sitio.

public

Este directorio tiene las imágenes que se muestran en las distintas vistas del proyecto, así como las hojas de estilo empleadas.

Pues eso, que vamos a empezar por el principio con una forma buena bonita y barata de instalar Ruby on Rails en Ubuntu 8.04.

Vamos por pasos:

1. Instalar Build-Essential : sudo apt-get install build-essential
2. Instalamos los paquetes necesarios para que rails funcione: sudo apt-get install ruby ri rdoc mysql-server libmysql-ruby ruby1.8-dev irb1.8 libdbd-mysql-perl libdbi-perl libmysql-ruby1.8 libmysqlclient15off libnet-daemon-perl libplrpc-perl libreadline-ruby1.8 libruby1.8 mysql-client-5.0 mysql-common mysql-server-5.0 rdoc1.8 ri1.8 ruby1.8 libopenssl-ruby1.8
3. Descargamos, descomprimimos y configuramos Rails: sudo wget http://rubyforge.org/frs/download.php/20989/rubygems-0.9.4.tgz
   tar xvzf rubygems-0.9.4.tgz
   cd rubygems-0.9.4
   sudo ruby setup.rb
4. Instalamos Rails: sudo gem install rails –include-dependencies (con dos guiones “- -” include) IMPORTANTE: este paso puede dar un error del tipo could not find rails >0. Simplemente volvemos a ejecutar la orden y ya deberia funcionar.
5. Y un par de herramientas para la gestion de las bases de datos MySQL: sudo apt-get install mysql-query-browser
   sudo apt-get install mysql-admin
6. Por ultimo y opcionalmente abrimos Aptana, esperamos e instalamos las gemas(gems) que nos sugiera.

Tras este articulo le devuelvo la conexion a nuestros estudios centrales, donde mis compañeros os enseñaran a trabajar con Rails.

P.D.: Inestimable la colaboracion de Victor para este post.

Redirige a una WEB
link_to (TEXTO, opciones = {}, HASH_atributos_HTML_CSS = nil)
:confirm => “TEXTO pregunta”
:popup => true || array of window options
# link_to “View Image”, { :action => “view” }, :popup => ['new_window_name', 'height=300,width=600']
:method => symbol of HTTP verb

Insertar IMAGENES
image_tag(“icon.png”, :size => “16×10″, :alt => “ALT”)

Redirige a una Accion
redirect_to(:controller => ‘controlador’, :action => ‘accion’)

RENDER

Genera codigo HTML a partir de Plantillas(layouts), vistas (views\*.html.erb), vistas parciales(views\_*.html.erb)

render :action=>Accion, :layout => “layout”
render :partial => “_vista”,:object => @new_person,:collection => @winners

Nota: Si pasamos una colection Acedemos a cada elementos por el nombre del PARTIAL “vista”

Busquedas en la BBDD

ObjetoTabla.find_by_CAMPO(“TEXTO”)
#busca por campo

ObjetoTabla.find(:all,:order => :Campo)
#busca TODOS y ordena por Campo

ObjetoTabla.find(:all,:conditions => ARRAY)
#pasa Parametros en un ARRAY tipo ["campo = ?",campo]

ObjetoTabla.find(ID)
#Busca por ID

ObjetoTabla.find(ID,:params => HASH)
#pasa Parametros en un HASH

Comandos para las Migraciones de la BBDD

create_table :productos do |t| # Crea la Tabla productos
t.string :nombre # Crea el campo nombre de tipo string

drop_table :productos # Borra la tabla productos

add_column :productos, :precio, :decimal, :default=> 0, :scale=>2, :precision =>8
#Añade un campo

remove_column :productos, :precio
# Borra un campo

Producto.create :nombre => “producto ejemplo”,:autor => “21234″
#crea un Producto

Protucto.find_by_nombre(“producto ejemplo”).destroy
#elimina un producto

Formateo De Datos

.strftime(“Creado el %d/%m/%Y a las %H:%M:%S”)
#formatea Fecha y hora

number_to_currency(numero, :unit => “€;”, :separator => “,”, :delimiter => “”)
#Formatea Moneda

Links API Ruby

Oficial http://www.ruby-doc.org/core/
Otra http://www.ruby-doc.org/docs/ProgrammingRuby/html/builtins.html

Links API Rails

Oficial http://api.rubyonrails.org/
Otra http://caboo.se/doc/files/vendor/rails/railties/CHANGELOG.html

En este tutorial Desarrollaremos un bingo para un solo usuario utilizando sessiones para guardar el progreso de la partida

Creamos la Aplicacion

rails bingo

Ahora metemos en en la carpeta \app\models las clase Bingo.rb y Carton.rb

class Bingo
attr_accessor :bombo
attr_accessor :mesa
def initialize
@bombo=Array.new
@mesa=Array.new
(0…80).each {|x| @bombo[x]= true}
end
# Devuelve un numero aleatorio y Apunta que salio
def canta
num= rand(80)+1
until self.bombo[num]
num= rand(80)
end
self.bombo[num] = false
mesa << num
num
end
def bombo_vacio?
res=false
self.bombo.each {|x| res=true if x}
res
end
def ver_bolas
@mesa.sort
end
end
class Carton
attr_accessor :carton
attr_accessor :lineas_cantadas
def initialize
numeros=Array.new
while numeros.size < 15 #Genera 15 Numeros Unicos
numeros<< rand(79)+1
numeros.uniq!
end
numeros.sort! # Los Ordena
carton=Array.new
(0…3).each do |y| # Los deordena de Arriba a Abbajo y de Izquierda a Dedecha
fila=Array.new
(0…5).each do |x|
fila[x]= numeros[x*3+y]
end
carton[y]= fila
end
@carton=carton
@lineas_cantadas= Array.new
(0…3).each do|x| # Define que no se han cantado Lineas
@lineas_cantadas[x]=false
end
end
def recorrer
self.carton.each_index do |nlinea|
self.carton[nlinea].each_index do |num|
yield(nlinea,num)
end
end
end

def tachar_numero(num)
res=false
self.recorrer do |x,y|
if self.carton[x][y]==num
self.carton[x][y]*=-1
res=true
end
end
res
end
# Devuelve si se canta linea y si se canta apunta que se canto
def es_linea?
res= false
(0…3).each do |x|
linea= true
(0…5).each do |y|
if self.carton[x][y] >0
linea=false
end
end
if linea and !self.lineas_cantadas[x]
res=true
self.lineas_cantadas[x]=true
end
end
res
end
def es_bingo?
res=true
self.recorrer { |x,y| res=false if self.carton[x][y] > 0}
res
end
end

creamos el Controlador

ruby script\generate controller bingo

Y lo Editamos

class BingoController < ApplicationController
#Pagina principal Recoge los valores de la sesion y segun Estado este
#Parado => Partida sin empezar
#Funcionando => Canta una bola y muestra el resultado
#hasta_en_fin => Juega Hasta el final y guarda lo que pasa en @mensaje
def index
@partida=busca_partida
@cartones=busca_cartones
@mensaje= Array.new
@estado=busca_estado
bolas_sacadas=0
salir=false
if @estado != “parado”
while (@estado == “hasta_el_fin” or bolas_sacadas==0) and !salir
@bola= @partida.canta
@bolas=@partida.ver_bolas
bolas_sacadas+=1
@cartones.each do|c|
n_carton= @cartones.index(c)
if c.tachar_numero(@bola)
@mensaje << “Se Tacha el numero #@bola en el carton numero #{n_carton}”
if c.es_linea?
@mensaje << “Cantas Linea en el carton numero #{n_carton}”
if c.es_bingo?
@mensaje << “El Carton numero #{n_carton} ha Hecho Bingo”
@mensaje << “Ha necesitado #{bolas_sacadas} Bolas”
salir=true
session[:cartones]=nil
session[:partida]=nil
session[:estado]=nil
break
end
end
end
end
end
end
end
# Añade un carton
def compra_carton
@cartones=busca_cartones
@cartones << Carton.new
session[:cartones] =@cartones
ir_a_index
end
# Solo regirige al index
def ir_a_index(msg = nil)
redirect_to :action => :index
end
# Devuelve la PARTIDA almacenados en la Session o una PARTIDA Nueva
def busca_partida
session[:partida] ||= Bingo.new
end
# Devuelve un Array con los cartones almacenados en la Session o una Array Nuevo
def busca_cartones
session[:cartones] ||= Array.new
end
# Devuelve el Estadoalmacenado en la Session o “parado” si no hay session
def busca_estado
session[:estado] ||= “parado”
end
# si esisten cartones Pones ESTADO = hasta_el_fin
def hasta_el_fin
@cartones=busca_cartones
session[:estado] = “funcionando” if @cartones.size>0
session[:estado] = “hasta_el_fin”
ir_a_index
end
# Si esisten cartones Pones ESTADO = “funcionando”
def empezar
@cartones=busca_cartones
session[:estado] = “funcionando” if @cartones.size>0
ir_a_index
end
end

Ya esta el programa ahora necesitamos gestionar como mostrarlo. Para lo que usaremos plantillas (Layouts) y Vistas

Primero la Plantilla, creamos \app\views\layouts\bingo.html.erb

<!DOCTYPE html PUBLIC “-//W3C//DTD XHTML 1.0 Transitional//EN”
“http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd”>
<html xmlns=”http://www.w3.org/1999/xhtml” xml:lang=”en” lang=”en”>
<head>
<meta http-equiv=”content-type” content=”text/html;charset=UTF-8″ />
<title>Productos: <%= controller.action_name %></title>
<%= stylesheet_link_tag ‘bingo’ %>
<%= javascript_include_tag :defaults %>
</head>
<body>
<h1>Bingo</h1>
<div id=”all”>
<div id=”cabecera”>
<h2>BINGO SOBRE RAILES</h2>
</div>
<div id=”izquierda”>
<h2>Numeros Cantados</h2>
<ul>
<%= render(:partial => “bolas”, bject => @bolas) %>
</ul>
</div>
<div id=”contenedor”>
<div id=”centro”>
<%= yield %>
</div>
<div id=”derecha”>
<ul>
<li><%= button_to “Comprar Carton” , :action => :compra_carton %></li>
<li><%= button_to “Empezar”, :action => :empezar %></li>
<li><%= button_to “Ir al Final” , :action => :hasta_el_fin %></li>
</ul>
</div>
</div>
</div>
</body>
</html>

Ahora las Vistas:

\app\views\bingo\index.html.erb es la vista de la Accion index

<div class=”cartones”>
<% if @cartones.size>0 %>
<% @cartones.each do |c| %>
<div class=”carton”>
<table>
<% c.carton.each do |linea|%>
<tr>
<% linea.each do |num|%>
<td <%= ‘class=”tachado”‘ if num >0 %>> <%= ” #{num.abs} ” %></td>
<% end %>
</tr>
<% end%>
</table>
</div>
<% end %>
<% else %>
<h2>Bienvenido a Bingo sobre Railes </h2>
<h3>compra uno o mas cartones y dale a empezar</h3>
<% end %>
</div>
<% if @bola %>
<div id=”pantalla”>
<p><%= @bola %></p>
<% if @mensaje %>
<ul>
<% @mensaje.each do |m| %>
<li><%= h(m) %></li>
<% end %>
</ul>
<% end %>
</div>
<% end %>

\app\views\bingo\_bolas.html.erb es llamada desde la plantilla con <%= render(:partial => “bolas”, bject => @bolas) %>

<ul>
<% if @bolas %>
<% @bolas.each do |bola_salida| %>
<li><%= bola_salida %></li>
<% end %>
<% end %>
</ul>

Por ultimo podemos darle Estilos con \public\stylesheets\bingo.css

BODY{ padding: 1em 1%; text-align:center;}
H1{display:none;}
UL{
list-style:none;
padding:0px;
margin:0px;
}

#all
{
width: 100%;
}
#cabecera
{
padding:0.4em 0%;
margin: 0em 0% 0.2em;
background:#CCCCCC;
}
#izquierda
{
float:left;
width: 20%;
background:#FFFFCC;
}
#contenedor
{
float:left;
width:80%;
}
#centro
{
float:left;
width:70%;
}
#derecha
{
float:right;
width:28%;
padding: 1em 0% 1em 0%;
background:#FFFFCC;
}
#derecha INPUT
{
width:70%;
padding: 0.3em 5%;
margin: 0.3em auto;
}
.carton
{
width:23%;
float:left;
padding: 0.5em 0.5%;
margin: 0.5em 0.5%;
background:#FFCC99;
}
.carton TABLE
{
width:90%;
margin:auto;
}
.carton TABLE TD{color:#009900 ;}
.carton TABLE TD.tachado{color: #990000 ;}
#pantalla{ clear:both;}
#pantalla P
{
width: 4em;
font-size:2em;
padding: 0.5em;
background:#99FFFF;
margin:auto;
}

Ruby es un lenguaje de script interpretado, orientado a objetos, rápido y sencillo. No obstante, no es la panacea del programador. Las características básicas del lenguaje son las siguientes:

• Los comentarios comienzan por #.
• Las sentencias no terminan en ;.
• Se pueden evitar los paréntesis cuando no haya ambigüedad.
• Las variables locales comienzan por minúscula.
• Las constantes empiezan por mayúscula.

Los recursos que se emplearán serán el comando irb y la API de Ruby (http://www.ruby-doc.com/core/).

La clase Fixnum.

Son los números enteros del rango 2^-30 a 2^30. Si se sobrepasa el límite del rango tras una operación, el tipo de la variable pasa automáticamente a Bignum. Como todo en Ruby es un objeto, un número constante tiene métodos a los que se puede invocar. Algunos métodos destacados son to_s (entero a string), to_f (entero a float), divmod (devuelve un array con el resultado y el cociente de una división) y remainder (retorna el resto de una división).

La clase Float.

Representa los números reales, en coma flotante con doble precisión. Algunos de los métodos que presenta son to_s (float a string), to_i, to_int, truncate (float a entero, truncando la parte decimal) y round (redondear a entero más cercano).

Los boolenanos.

En Ruby no existe un tipo de dato booleano, explícitamente. No obstante, reconoce los valores false y nil. Todo lo demás es falso (incluido 0, a difierencia de otros lenguajes de programación).

La clase String.

Cadenas de texto, encerradas entre comillas simples o dobles. La diferencia entre usar unas u otras estriba en que con las dobles, se parsea el contenido la cadena (por ejemplo, \n se traduce como un salto de línea), mientras que con las simples, la cadena no se traduce. Es posible acceder a los caracteres de la cadena a través de su índice. Si éstos son negativos, se empieza a contar desde el final de la cadena. Los métodos más destacados son los siguientes:

• capitalize: hace mayúscula la inicial de la cadena.
• concat / <<: concatena una cadena a otra.
• []: devuelve el código ascii del carácter que ocupa la posición indicada.
• delete: borrar de la cadena el carácter indicado.
• eql? / == / equal?: los tres comprueban si dos cadenas son iguales. Además, equal? compara también que se trate del mismo objeto.
• to_i / to_f / to_sym: transformar una cadena en entero, float o símbolo (un símbolo es una variable que apunta a una posición que contiene una cadena igual al nombre del símbolo. Su ventaja es que símbolos con el mismo nombre hacen referencia a la misma cadena).
• upcase / downcase / swapcase: transformar una cadena a mayúsculas, minúsculas o intercambiar mayúsculas y minúsculas, y viceversa.
• reverse: invertir el orden de los caracteres de una cadena.
• next: retorna el siguiente caracter de la cadena, según el orden alfabético.
• chop: elimina el último carácter de una cadena.
• chomp: eliminar el salto de línea final de una cadena.
• strip / lstrip / rstrip: eliminar los espacios en blanco de una cadena por ambos lados, sólo la izquierda o sólo la derecha.
• split: generar un array a partir de un string, indicando el patrón separador de componentes.

Rangos.

Para comprobar la inclusión de un valor en un rango, se emplea el operador ===. Los rangos pueden ser de dos tipos:

• (a..b): es equivalente a [a,b].
• (a…b): es equivalente a [a,b).

Algunos métodos son: begin, end (devuelven el extremo inferior y superior del rango), exclude_end (informa acerca de la exclusividad del extremo superior del rango), to_a (convertir un rango en un array).

Expresiones regulares.

Es un patrón que generalizar un conjunto de cadenas. Pertenecen a la clase Regexp. Para comprobar si una cadena cumple una expresión regular, se emplea el operador =~.

Símbolos.

Anteriormente, ya se ha explicado lo que es un símbolo. Para determinar si se debe emplear una cadena o un símbolo, hay que pensar sobre si lo importante es la identidad del objeto y el contenido del objeto. Algunos de los métodos que se pueden aplicar son to_i (símbolo a entero), to_f (símbolo a float) y to_s (símbolo a string).

Arrays y hashes.

Son colecciones de cualquier tipo de objetos (pueden ser distintos dentro de la misma colección). Los arrays son indexados mediante enteros, a diferencia de los hashes, que se indexan mediante cualquier objeto (que también pueden ser de distinto tipo). Por tanto, el array es más eficiente (está ordenado), mientras que el hash es más flexible. Los métodos más importantes son:

• join: genera un string a partir de un array. Debemos indicar el patrón que separará las componentes en el array.
• sort: ordena el array.
• rsort: invierte el orden de los elementos del array.
• length: proporciona la longitud del array.
• flatten: desanida el array (transforma un array bidimensional o unidimensional).
• uniq: elimina elementos duplicados.
• include?: comprobar si un elemento pertenece a un array.

Los arrays se crean entre corchetes, mientras que los hashes, entre llaves, indicando clave y valor.

Estructuras del lenguaje.

if / elsif / else

if condicion1

sentecias

elsif condicion2

sentencias

else

sentencias

end

unless: similar al if, se verifica cuando la condición no se cumple. No existe elsunless.

unless condicion

sentencias

end

case: es el switch de otros lenguajes. En Ruby, el elemento estudiado puede ser de cualquier tipo. Permite estudiar la inclusión en un rango, la clase a que pertenece una variable o el cumplimiento de una expresión regular.

case a

when a = ..

sentencias

when a = ..

sentencias

else

sentencias

end

while: bucle más sencillo

while condicion

sentencias

end

until: funciona de forma similar al while, pero se ejecuta mientras no se verifica la condición:

until condicion

sentencias

end

Interrupción de los bucles:

• break: sale del bucle.
• next: pasa a la siguiente iteración del bucle.
• redo: reinicia la iteración actual.
• return: sale del bucle y del método que lo contiene.

Desde el directorio de ruby

Rails calculadora #Creamos la Aplicación
cd calculadora
ruby script/generate controller calculadora # Creamos el Controlador

Editamos \app\controllers\calculadora_controller.rb

empezamos por la Vista index.html.erb.

<% form_for :calcu, :url => { :action => :resultado } do |formulario| %>

<label for=”numero1″>Numero

<%= text_field_tag ( “numero1″, “”, {“size” => 30}) %>

</label>

<label for=”numero2″>Numero

<%= text_field_tag ( “numero2″, “”, {“size” => 30}) %>

</label>

<fieldset> <legend>Operaciones</legend>

<label for=”operacion_suma”></label>

<%= radio_button_tag “operacion”, ‘suma’, true %>Suma

<label for=”operacion_resta”></label>

<%= radio_button_tag “operacion”, ‘resta’ %>Resta

<label for=”operacion_multiplica”></label>

<%= radio_button_tag “operacion”, ‘multiplica’ %>Multiplicacion

<label for=”operacion_divide”></label>

<%= radio_button_tag “operacion”, ‘divide’ %>Division

</fieldset>

<input type=”submit” value=”Calcular”/>

<% end %>

La declaración del formulario es diferente de las declaraciones de los Inputs porque la Etiqueta start_form_tag no funciona en rails 2 así que Las variables :rails y |formulario | no se usan

Este formulario Llama a la Acción Resultado. Tenemos que crearla en el controlador calculadora_controller.rb

@num1= params[:numero1].to_f
@num2= params[:numero2].to_f
@operacion = params[:operacion]
case @operacion
when “suma”
@resultado = @num1 + @num2
@operacion=”+”
when “resta”
@resultado = @num1 – @num2
@operacion=”-”
when “multiplica”
@resultado = @num1 * @num2
@operacion=”*”
when “divide”
@resultado = @num1 / @num2
@operacion=”/”
end
end

<h1>Resultado de la operacion</h1>

<br />

<%= “#@num1 #@operacion #@num2 = #@resultado” %>

<br />

<%= link_to “Volver”, :action => “index” %>

Ahora se podría poner guapo creando la plantilla \app\views\layouts\calculadora.html.erb. como esta:

<!DOCTYPE html PUBLIC “-//W3C//DTD XHTML 1.0 Transitional//EN”

“http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd”>

<html xmlns=”http://www.w3.org/1999/xhtml” xml:lang=”en” lang=”en”>

<head>

<meta http-equiv=”content-type” content=”text/html;charset=UTF-8″ />

<title>Calculadora: <%= controller.action_name %></title>

<%= stylesheet_link_tag ‘calculadora’ %>

</head>

<body>

<p style=”color: green”><%= flash[:notice] %></p>

<div id=”all”>

<div id=”cabecera”><h1>MiniCalculadora sobre Railes</h1></div>

<div id=”cuerpo”>

<%= yield %>

</div>

</div>

</body>

</html>

Con stylesheet_link_tag ‘calculadora’ es un Link a una Hoja de estilo en \public\stylesheets llamada calculadora.css:

• La situación del usuario: dónde está.
• Qué contiene la página que está visitando.
• A dónde se puede ir desde la página en la que está situado.
• Cómo usar la web que visita.

Convenciones sobre la navegación.

Describen una serie de elementos que deben estar presentes en una página para asegurarse de que su uso resulta
intuitivo al usuario.

Navegación persistente

Se refiere a los elementos comunes a todas las páginas de nuestra web que permiten navegar de unas a otras o realizar
acciones que no son dependientes del contenido específico de una página en particular.

• Identificador del sitio: generalmente en la parte superior izquierda
• Secciones: deben ser fácilmente localizables
• Enlace a la página principal: debe estar siempre presente y ser fácilmente localizable
• Utilidades: ofrecen la posibilidad de realizar acciones que no pertenecen a la jerarquía de información de la página.
• Búsqueda:
  • Debe ser fácilmente identificable.
  • Simple: evitar instrucciones y opciones.
• Nombre de la página: único para cada página, situado de forma que sea fácilmente localizable.
• Migas de pan: situadas de forma localizable, pero discreta. Describen la situación del usuario en la jerarquía de la web.
• Navegación local: depende del contexto de la página. Enlaza a contenidos de interés o relacionados con los de la página actual.