ruby on rails avanzadodemiurgo.org/charlas/semruby-3.pdf · ruby on rails avanzado esteban manchado...
Post on 13-Oct-2018
213 Views
Preview:
TRANSCRIPT
Indice
1 MVCModeloVistaControlador
2 Facilidades adicionalesEntornosActionMailerExtensiones al lenguaje
3 ConclusionesLo bueno/lo maloConsejos varios
Indice
1 MVCModeloVistaControlador
2 Facilidades adicionalesEntornosActionMailerExtensiones al lenguaje
3 ConclusionesLo bueno/lo maloConsejos varios
Relaciones
• Los modelos estan relacionados entre sı
• Hay varias relaciones definidas en Rails
• has many, belongs to, has and belongs to, etc.
• Declaracion en los modelos, limpia y legible
• Convenciones para reducir al mınimo el codigo...
• ...aunque todo se puede personalizar, claro
• Tambien se pueden afinar las relaciones con condiciones
Relaciones
• Los modelos estan relacionados entre sı
• Hay varias relaciones definidas en Rails
• has many, belongs to, has and belongs to, etc.
• Declaracion en los modelos, limpia y legible
• Convenciones para reducir al mınimo el codigo...
• ...aunque todo se puede personalizar, claro
• Tambien se pueden afinar las relaciones con condiciones
Relaciones
• Los modelos estan relacionados entre sı
• Hay varias relaciones definidas en Rails
• has many, belongs to, has and belongs to, etc.
• Declaracion en los modelos, limpia y legible
• Convenciones para reducir al mınimo el codigo...
• ...aunque todo se puede personalizar, claro
• Tambien se pueden afinar las relaciones con condiciones
Relaciones
• Los modelos estan relacionados entre sı
• Hay varias relaciones definidas en Rails
• has many, belongs to, has and belongs to, etc.
• Declaracion en los modelos, limpia y legible
• Convenciones para reducir al mınimo el codigo...
• ...aunque todo se puede personalizar, claro
• Tambien se pueden afinar las relaciones con condiciones
Relaciones
• Los modelos estan relacionados entre sı
• Hay varias relaciones definidas en Rails
• has many, belongs to, has and belongs to, etc.
• Declaracion en los modelos, limpia y legible
• Convenciones para reducir al mınimo el codigo...
• ...aunque todo se puede personalizar, claro
• Tambien se pueden afinar las relaciones con condiciones
Relaciones
• Los modelos estan relacionados entre sı
• Hay varias relaciones definidas en Rails
• has many, belongs to, has and belongs to, etc.
• Declaracion en los modelos, limpia y legible
• Convenciones para reducir al mınimo el codigo...
• ...aunque todo se puede personalizar, claro
• Tambien se pueden afinar las relaciones con condiciones
Relaciones
• Los modelos estan relacionados entre sı
• Hay varias relaciones definidas en Rails
• has many, belongs to, has and belongs to, etc.
• Declaracion en los modelos, limpia y legible
• Convenciones para reducir al mınimo el codigo...
• ...aunque todo se puede personalizar, claro
• Tambien se pueden afinar las relaciones con condiciones
Relaciones: ejemplo
class Curso < ActiveRecord::Basehas_many :documentoshas_many :examenes, :class_name => ’Documento’,
:conditions => "tipo = ’examen’"has_and_belongs_to_many :alumnos, :order => ’nombre’belongs_to :temporada, :class_name => ’AnoAcademico’,
:foreign_key => ’curso_id’end
Relaciones: ejemplo
class Curso < ActiveRecord::Basehas_many :documentoshas_many :examenes, :class_name => ’Documento’,
:conditions => "tipo = ’examen’"has_and_belongs_to_many :alumnos, :order => ’nombre’belongs_to :temporada, :class_name => ’AnoAcademico’,
:foreign_key => ’curso_id’end
Relaciones: ejemplo
class Curso < ActiveRecord::Basehas_many :documentoshas_many :examenes, :class_name => ’Documento’,
:conditions => "tipo = ’examen’"has_and_belongs_to_many :alumnos, :order => ’nombre’belongs_to :temporada, :class_name => ’AnoAcademico’,
:foreign_key => ’curso_id’end
Relaciones: ejemplo
class Curso < ActiveRecord::Basehas_many :documentoshas_many :examenes, :class_name => ’Documento’,
:conditions => "tipo = ’examen’"has_and_belongs_to_many :alumnos, :order => ’nombre’belongs_to :temporada, :class_name => ’AnoAcademico’,
:foreign_key => ’curso_id’end
Relaciones: ejemplo
class Curso < ActiveRecord::Basehas_many :documentoshas_many :examenes, :class_name => ’Documento’,
:conditions => "tipo = ’examen’"has_and_belongs_to_many :alumnos, :order => ’nombre’belongs_to :temporada, :class_name => ’AnoAcademico’,
:foreign_key => ’curso_id’end
Relaciones: ejemplo de uso
c = Curso.find(...)
c.documentos.each {|d| ...}c.documentos.sizec.documento_ids = [1, 2, 3]
c.examenes.empty?c.examenes << Documento.create(:tipo => ’examen’, ...)
c.alumnos.push_with_attributes(:reservado => true)
Relaciones: ejemplo de uso
c = Curso.find(...)
c.documentos.each {|d| ...}c.documentos.sizec.documento_ids = [1, 2, 3]
c.examenes.empty?c.examenes << Documento.create(:tipo => ’examen’, ...)
c.alumnos.push_with_attributes(:reservado => true)
Relaciones: ejemplo de uso
c = Curso.find(...)
c.documentos.each {|d| ...}c.documentos.sizec.documento_ids = [1, 2, 3]
c.examenes.empty?c.examenes << Documento.create(:tipo => ’examen’, ...)
c.alumnos.push_with_attributes(:reservado => true)
Relaciones: ejemplo de uso
c = Curso.find(...)
c.documentos.each {|d| ...}c.documentos.sizec.documento_ids = [1, 2, 3]
c.examenes.empty?c.examenes << Documento.create(:tipo => ’examen’, ...)
c.alumnos.push_with_attributes(:reservado => true)
Relaciones: ejemplo de uso
c = Curso.find(...)
c.documentos.each {|d| ...}c.documentos.sizec.documento_ids = [1, 2, 3]
c.examenes.empty?c.examenes << Documento.create(:tipo => ’examen’, ...)
c.alumnos.push_with_attributes(:reservado => true)
Relaciones: ejemplo de uso
c = Curso.find(...)
c.documentos.each {|d| ...}c.documentos.sizec.documento_ids = [1, 2, 3]
c.examenes.empty?c.examenes << Documento.create(:tipo => ’examen’, ...)
c.alumnos.push_with_attributes(:reservado => true)
Relaciones: ejemplo de uso
c = Curso.find(...)
c.documentos.each {|d| ...}c.documentos.sizec.documento_ids = [1, 2, 3]
c.examenes.empty?c.examenes << Documento.create(:tipo => ’examen’, ...)
c.alumnos.push_with_attributes(:reservado => true)
Validadores
• En general, se intentan mantener en el codigo
• Dos estrategias basicas: marcar campos o validacion general
• Para el primer caso, tenemos varios metodos (de clase)
• Para el segundo podemos sobrecargar validate (de ejemplar)
• En validate, anadimos los errores a errors
• Podemos combinarlos, claro
Validadores
• En general, se intentan mantener en el codigo
• Dos estrategias basicas: marcar campos o validacion general
• Para el primer caso, tenemos varios metodos (de clase)
• Para el segundo podemos sobrecargar validate (de ejemplar)
• En validate, anadimos los errores a errors
• Podemos combinarlos, claro
Validadores
• En general, se intentan mantener en el codigo
• Dos estrategias basicas: marcar campos o validacion general
• Para el primer caso, tenemos varios metodos (de clase)
• Para el segundo podemos sobrecargar validate (de ejemplar)
• En validate, anadimos los errores a errors
• Podemos combinarlos, claro
Validadores
• En general, se intentan mantener en el codigo
• Dos estrategias basicas: marcar campos o validacion general
• Para el primer caso, tenemos varios metodos (de clase)
• Para el segundo podemos sobrecargar validate (de ejemplar)
• En validate, anadimos los errores a errors
• Podemos combinarlos, claro
Validadores
• En general, se intentan mantener en el codigo
• Dos estrategias basicas: marcar campos o validacion general
• Para el primer caso, tenemos varios metodos (de clase)
• Para el segundo podemos sobrecargar validate (de ejemplar)
• En validate, anadimos los errores a errors
• Podemos combinarlos, claro
Validadores
• En general, se intentan mantener en el codigo
• Dos estrategias basicas: marcar campos o validacion general
• Para el primer caso, tenemos varios metodos (de clase)
• Para el segundo podemos sobrecargar validate (de ejemplar)
• En validate, anadimos los errores a errors
• Podemos combinarlos, claro
Validadores: ejemplo
class Alumno < ActiveRecord::Basevalidates_presence_of :num_sociovalidates_inclusion_of :edad,
:in => 18..100,:message => "Dos rombos"
validates_exclusion_of :nombre,:in => [’Pepito’, ’Juanito’],:message => "Te odio"
validates_format_of :email,:with => /^[\w\.]+@[\w\.]+$/
end
Validadores: ejemplo
class Alumno < ActiveRecord::Basevalidates_presence_of :num_sociovalidates_inclusion_of :edad,
:in => 18..100,:message => "Dos rombos"
validates_exclusion_of :nombre,:in => [’Pepito’, ’Juanito’],:message => "Te odio"
validates_format_of :email,:with => /^[\w\.]+@[\w\.]+$/
end
Validadores: ejemplo
class Alumno < ActiveRecord::Basevalidates_presence_of :num_sociovalidates_inclusion_of :edad,
:in => 18..100,:message => "Dos rombos"
validates_exclusion_of :nombre,:in => [’Pepito’, ’Juanito’],:message => "Te odio"
validates_format_of :email,:with => /^[\w\.]+@[\w\.]+$/
end
Validadores: ejemplo
class Alumno < ActiveRecord::Basevalidates_presence_of :num_sociovalidates_inclusion_of :edad,
:in => 18..100,:message => "Dos rombos"
validates_exclusion_of :nombre,:in => [’Pepito’, ’Juanito’],:message => "Te odio"
validates_format_of :email,:with => /^[\w\.]+@[\w\.]+$/
end
Validadores: ejemplo
class Alumno < ActiveRecord::Basevalidates_presence_of :num_sociovalidates_inclusion_of :edad,
:in => 18..100,:message => "Dos rombos"
validates_exclusion_of :nombre,:in => [’Pepito’, ’Juanito’],:message => "Te odio"
validates_format_of :email,:with => /^[\w\.]+@[\w\.]+$/
end
Validadores: otro ejemplo
class Alumno < ActiveRecord::Basedef validate(a)errors.add_on_empty("num_socio")errors.add("edad", "Muy joven") \
unless (18..100).include? a.edaderrors.add("email", "Direccion incorrecta") \
if a.email !~ /^[\w\.]+@[\w\.]+$/end
end
Validadores: otro ejemplo
class Alumno < ActiveRecord::Basedef validate(a)errors.add_on_empty("num_socio")errors.add("edad", "Muy joven") \
unless (18..100).include? a.edaderrors.add("email", "Direccion incorrecta") \
if a.email !~ /^[\w\.]+@[\w\.]+$/end
end
Validadores: otro ejemplo
class Alumno < ActiveRecord::Basedef validate(a)errors.add_on_empty("num_socio")errors.add("edad", "Muy joven") \
unless (18..100).include? a.edaderrors.add("email", "Direccion incorrecta") \
if a.email !~ /^[\w\.]+@[\w\.]+$/end
end
Validadores: otro ejemplo
class Alumno < ActiveRecord::Basedef validate(a)errors.add_on_empty("num_socio")errors.add("edad", "Muy joven") \
unless (18..100).include? a.edaderrors.add("email", "Direccion incorrecta") \
if a.email !~ /^[\w\.]+@[\w\.]+$/end
end
Validadores: otro ejemplo
class Alumno < ActiveRecord::Basedef validate(a)errors.add_on_empty("num_socio")errors.add("edad", "Muy joven") \
unless (18..100).include? a.edaderrors.add("email", "Direccion incorrecta") \
if a.email !~ /^[\w\.]+@[\w\.]+$/end
end
Migraciones
• Expresan cambios en la base de datos
• Solo MySQL y PostgreSQL por ahora
• Permiten actualizar facilmente
• Son clases en ficheros independientes (en db/migrate)
• Se crean nuevas migraciones con./script/generate migration NombreMigracion
• Para actualizar: rake migrate
• Mecanismos de descripcion de la migracion:
• ActiveRecord para los datos• create table, remove column, etc. para casos comunes• execute para SQL directo
Migraciones
• Expresan cambios en la base de datos
• Solo MySQL y PostgreSQL por ahora
• Permiten actualizar facilmente
• Son clases en ficheros independientes (en db/migrate)
• Se crean nuevas migraciones con./script/generate migration NombreMigracion
• Para actualizar: rake migrate
• Mecanismos de descripcion de la migracion:
• ActiveRecord para los datos• create table, remove column, etc. para casos comunes• execute para SQL directo
Migraciones
• Expresan cambios en la base de datos
• Solo MySQL y PostgreSQL por ahora
• Permiten actualizar facilmente
• Son clases en ficheros independientes (en db/migrate)
• Se crean nuevas migraciones con./script/generate migration NombreMigracion
• Para actualizar: rake migrate
• Mecanismos de descripcion de la migracion:
• ActiveRecord para los datos• create table, remove column, etc. para casos comunes• execute para SQL directo
Migraciones
• Expresan cambios en la base de datos
• Solo MySQL y PostgreSQL por ahora
• Permiten actualizar facilmente
• Son clases en ficheros independientes (en db/migrate)
• Se crean nuevas migraciones con./script/generate migration NombreMigracion
• Para actualizar: rake migrate
• Mecanismos de descripcion de la migracion:
• ActiveRecord para los datos• create table, remove column, etc. para casos comunes• execute para SQL directo
Migraciones
• Expresan cambios en la base de datos
• Solo MySQL y PostgreSQL por ahora
• Permiten actualizar facilmente
• Son clases en ficheros independientes (en db/migrate)
• Se crean nuevas migraciones con./script/generate migration NombreMigracion
• Para actualizar: rake migrate
• Mecanismos de descripcion de la migracion:
• ActiveRecord para los datos• create table, remove column, etc. para casos comunes• execute para SQL directo
Migraciones
• Expresan cambios en la base de datos
• Solo MySQL y PostgreSQL por ahora
• Permiten actualizar facilmente
• Son clases en ficheros independientes (en db/migrate)
• Se crean nuevas migraciones con./script/generate migration NombreMigracion
• Para actualizar: rake migrate
• Mecanismos de descripcion de la migracion:
• ActiveRecord para los datos• create table, remove column, etc. para casos comunes• execute para SQL directo
Migraciones
• Expresan cambios en la base de datos
• Solo MySQL y PostgreSQL por ahora
• Permiten actualizar facilmente
• Son clases en ficheros independientes (en db/migrate)
• Se crean nuevas migraciones con./script/generate migration NombreMigracion
• Para actualizar: rake migrate
• Mecanismos de descripcion de la migracion:
• ActiveRecord para los datos• create table, remove column, etc. para casos comunes• execute para SQL directo
Migraciones
• Expresan cambios en la base de datos
• Solo MySQL y PostgreSQL por ahora
• Permiten actualizar facilmente
• Son clases en ficheros independientes (en db/migrate)
• Se crean nuevas migraciones con./script/generate migration NombreMigracion
• Para actualizar: rake migrate
• Mecanismos de descripcion de la migracion:• ActiveRecord para los datos
• create table, remove column, etc. para casos comunes• execute para SQL directo
Migraciones
• Expresan cambios en la base de datos
• Solo MySQL y PostgreSQL por ahora
• Permiten actualizar facilmente
• Son clases en ficheros independientes (en db/migrate)
• Se crean nuevas migraciones con./script/generate migration NombreMigracion
• Para actualizar: rake migrate
• Mecanismos de descripcion de la migracion:• ActiveRecord para los datos• create table, remove column, etc. para casos comunes
• execute para SQL directo
Migraciones
• Expresan cambios en la base de datos
• Solo MySQL y PostgreSQL por ahora
• Permiten actualizar facilmente
• Son clases en ficheros independientes (en db/migrate)
• Se crean nuevas migraciones con./script/generate migration NombreMigracion
• Para actualizar: rake migrate
• Mecanismos de descripcion de la migracion:• ActiveRecord para los datos• create table, remove column, etc. para casos comunes• execute para SQL directo
Migraciones: ejemplo
class TablaIncidencias < ActiveRecord::Migrationdef self.up
create_table :incidencias do |t|# id automaticot.column :desc, :textt.column :autor, :string, :limit => 20
endIncidencia.create(:desc => ’Incidencia inicial’)
end
def self.downdrop_table :incidencias
endend
Migraciones: ejemplo
class TablaIncidencias < ActiveRecord::Migrationdef self.up
create_table :incidencias do |t|# id automaticot.column :desc, :textt.column :autor, :string, :limit => 20
endIncidencia.create(:desc => ’Incidencia inicial’)
end
def self.downdrop_table :incidencias
endend
Migraciones: ejemplo
class TablaIncidencias < ActiveRecord::Migrationdef self.up
create_table :incidencias do |t|# id automaticot.column :desc, :textt.column :autor, :string, :limit => 20
endIncidencia.create(:desc => ’Incidencia inicial’)
end
def self.downdrop_table :incidencias
endend
Migraciones: ejemplo
class TablaIncidencias < ActiveRecord::Migrationdef self.up
create_table :incidencias do |t|# id automaticot.column :desc, :textt.column :autor, :string, :limit => 20
endIncidencia.create(:desc => ’Incidencia inicial’)
end
def self.downdrop_table :incidencias
endend
Migraciones: ejemplo
class TablaIncidencias < ActiveRecord::Migrationdef self.up
create_table :incidencias do |t|# id automaticot.column :desc, :textt.column :autor, :string, :limit => 20
endIncidencia.create(:desc => ’Incidencia inicial’)
end
def self.downdrop_table :incidencias
endend
Migraciones: ejemplo
class TablaIncidencias < ActiveRecord::Migrationdef self.up
create_table :incidencias do |t|# id automaticot.column :desc, :textt.column :autor, :string, :limit => 20
endIncidencia.create(:desc => ’Incidencia inicial’)
end
def self.downdrop_table :incidencias
endend
Observadores
• Permiten ejecutar operaciones relacionadas con los modelos...
• ...sin acoplar ese codigo con el modelo
• Son clases normales, herederas de ActiveRecord::Observer
• Cada observador puede vigilar varios modelos
• Se especifica la lista de observadores de la aplicacion
• Se definen a mano, en app/models
• Diferentes enganches: before validation, after create,before save, ...
Observadores
• Permiten ejecutar operaciones relacionadas con los modelos...
• ...sin acoplar ese codigo con el modelo
• Son clases normales, herederas de ActiveRecord::Observer
• Cada observador puede vigilar varios modelos
• Se especifica la lista de observadores de la aplicacion
• Se definen a mano, en app/models
• Diferentes enganches: before validation, after create,before save, ...
Observadores
• Permiten ejecutar operaciones relacionadas con los modelos...
• ...sin acoplar ese codigo con el modelo
• Son clases normales, herederas de ActiveRecord::Observer
• Cada observador puede vigilar varios modelos
• Se especifica la lista de observadores de la aplicacion
• Se definen a mano, en app/models
• Diferentes enganches: before validation, after create,before save, ...
Observadores
• Permiten ejecutar operaciones relacionadas con los modelos...
• ...sin acoplar ese codigo con el modelo
• Son clases normales, herederas de ActiveRecord::Observer
• Cada observador puede vigilar varios modelos
• Se especifica la lista de observadores de la aplicacion
• Se definen a mano, en app/models
• Diferentes enganches: before validation, after create,before save, ...
Observadores
• Permiten ejecutar operaciones relacionadas con los modelos...
• ...sin acoplar ese codigo con el modelo
• Son clases normales, herederas de ActiveRecord::Observer
• Cada observador puede vigilar varios modelos
• Se especifica la lista de observadores de la aplicacion
• Se definen a mano, en app/models
• Diferentes enganches: before validation, after create,before save, ...
Observadores
• Permiten ejecutar operaciones relacionadas con los modelos...
• ...sin acoplar ese codigo con el modelo
• Son clases normales, herederas de ActiveRecord::Observer
• Cada observador puede vigilar varios modelos
• Se especifica la lista de observadores de la aplicacion
• Se definen a mano, en app/models
• Diferentes enganches: before validation, after create,before save, ...
Observadores
• Permiten ejecutar operaciones relacionadas con los modelos...
• ...sin acoplar ese codigo con el modelo
• Son clases normales, herederas de ActiveRecord::Observer
• Cada observador puede vigilar varios modelos
• Se especifica la lista de observadores de la aplicacion
• Se definen a mano, en app/models
• Diferentes enganches: before validation, after create,before save, ...
Observadores: ejemplo
class CursoObserver < ActiveRecord::Observerdef before_save(curso)curso.precio = curso.precio + " leuros"
end
def after_save(curso)Suceso.registra("Nuevo curso: ’#{curso.titulo}’")
endend
Observadores: ejemplo
class CursoObserver < ActiveRecord::Observerdef before_save(curso)curso.precio = curso.precio + " leuros"
end
def after_save(curso)Suceso.registra("Nuevo curso: ’#{curso.titulo}’")
endend
Observadores: ejemplo
class CursoObserver < ActiveRecord::Observerdef before_save(curso)curso.precio = curso.precio + " leuros"
end
def after_save(curso)Suceso.registra("Nuevo curso: ’#{curso.titulo}’")
endend
Observadores: ejemplo
class CursoObserver < ActiveRecord::Observerdef before_save(curso)curso.precio = curso.precio + " leuros"
end
def after_save(curso)Suceso.registra("Nuevo curso: ’#{curso.titulo}’")
endend
Observadores: ejemplo
class CursoObserver < ActiveRecord::Observerdef before_save(curso)curso.precio = curso.precio + " leuros"
end
def after_save(curso)Suceso.registra("Nuevo curso: ’#{curso.titulo}’")
endend
Observadores: ejemplo
class CursoObserver < ActiveRecord::Observerdef before_save(curso)curso.precio = curso.precio + " leuros"
end
def after_save(curso)Suceso.registra("Nuevo curso: ’#{curso.titulo}’")
endend
Indice
1 MVCModeloVistaControlador
2 Facilidades adicionalesEntornosActionMailerExtensiones al lenguaje
3 ConclusionesLo bueno/lo maloConsejos varios
Helpers
• Etiquetas HTML
• Paginacion
• Generacion de Javascript
• Generacion de URLs
• Operaciones comunes de texto
• Formato de numeros
• Generacion de trozos de la pagina
• Medicion de tiempos
Helpers
• Etiquetas HTML
• Paginacion
• Generacion de Javascript
• Generacion de URLs
• Operaciones comunes de texto
• Formato de numeros
• Generacion de trozos de la pagina
• Medicion de tiempos
Helpers
• Etiquetas HTML
• Paginacion
• Generacion de Javascript
• Generacion de URLs
• Operaciones comunes de texto
• Formato de numeros
• Generacion de trozos de la pagina
• Medicion de tiempos
Helpers
• Etiquetas HTML
• Paginacion
• Generacion de Javascript
• Generacion de URLs
• Operaciones comunes de texto
• Formato de numeros
• Generacion de trozos de la pagina
• Medicion de tiempos
Helpers
• Etiquetas HTML
• Paginacion
• Generacion de Javascript
• Generacion de URLs
• Operaciones comunes de texto
• Formato de numeros
• Generacion de trozos de la pagina
• Medicion de tiempos
Helpers
• Etiquetas HTML
• Paginacion
• Generacion de Javascript
• Generacion de URLs
• Operaciones comunes de texto
• Formato de numeros
• Generacion de trozos de la pagina
• Medicion de tiempos
Helpers
• Etiquetas HTML
• Paginacion
• Generacion de Javascript
• Generacion de URLs
• Operaciones comunes de texto
• Formato de numeros
• Generacion de trozos de la pagina
• Medicion de tiempos
Helpers
• Etiquetas HTML
• Paginacion
• Generacion de Javascript
• Generacion de URLs
• Operaciones comunes de texto
• Formato de numeros
• Generacion de trozos de la pagina
• Medicion de tiempos
Helpers: ejemplos
<%= text_field(:curso, :titulo) %><%= text_area(:curso, :observaciones, :rows => 10) %><%= pagination_links(paginador_cursos) %><%= text_field_with_auto_complete_field(:curso,
:titulo) %># En el controlador:# auto_complete_for :curso, :titulo<%= url_for(:action => ’show’, :id => 4) %><%= excerpt("Hola, mundo, ¿que tal?", "mundo", 3) %><%= sanitize("<form> literal <a onbla=’se borra’>") %><%= textilize("Formato _simple_.\n\nCon parrafos") %><%= highlight("Resalto como Google", "Google") %>
Helpers: ejemplos
<%= text_field(:curso, :titulo) %><%= text_area(:curso, :observaciones, :rows => 10) %><%= pagination_links(paginador_cursos) %><%= text_field_with_auto_complete_field(:curso,
:titulo) %># En el controlador:# auto_complete_for :curso, :titulo<%= url_for(:action => ’show’, :id => 4) %><%= excerpt("Hola, mundo, ¿que tal?", "mundo", 3) %><%= sanitize("<form> literal <a onbla=’se borra’>") %><%= textilize("Formato _simple_.\n\nCon parrafos") %><%= highlight("Resalto como Google", "Google") %>
Helpers: ejemplos
<%= text_field(:curso, :titulo) %><%= text_area(:curso, :observaciones, :rows => 10) %><%= pagination_links(paginador_cursos) %><%= text_field_with_auto_complete_field(:curso,
:titulo) %># En el controlador:# auto_complete_for :curso, :titulo<%= url_for(:action => ’show’, :id => 4) %><%= excerpt("Hola, mundo, ¿que tal?", "mundo", 3) %><%= sanitize("<form> literal <a onbla=’se borra’>") %><%= textilize("Formato _simple_.\n\nCon parrafos") %><%= highlight("Resalto como Google", "Google") %>
Helpers: ejemplos
<%= text_field(:curso, :titulo) %><%= text_area(:curso, :observaciones, :rows => 10) %><%= pagination_links(paginador_cursos) %><%= text_field_with_auto_complete_field(:curso,
:titulo) %># En el controlador:# auto_complete_for :curso, :titulo<%= url_for(:action => ’show’, :id => 4) %><%= excerpt("Hola, mundo, ¿que tal?", "mundo", 3) %><%= sanitize("<form> literal <a onbla=’se borra’>") %><%= textilize("Formato _simple_.\n\nCon parrafos") %><%= highlight("Resalto como Google", "Google") %>
Helpers: ejemplos
<%= text_field(:curso, :titulo) %><%= text_area(:curso, :observaciones, :rows => 10) %><%= pagination_links(paginador_cursos) %><%= text_field_with_auto_complete_field(:curso,
:titulo) %># En el controlador:# auto_complete_for :curso, :titulo<%= url_for(:action => ’show’, :id => 4) %><%= excerpt("Hola, mundo, ¿que tal?", "mundo", 3) %><%= sanitize("<form> literal <a onbla=’se borra’>") %><%= textilize("Formato _simple_.\n\nCon parrafos") %><%= highlight("Resalto como Google", "Google") %>
Helpers: ejemplos
<%= text_field(:curso, :titulo) %><%= text_area(:curso, :observaciones, :rows => 10) %><%= pagination_links(paginador_cursos) %><%= text_field_with_auto_complete_field(:curso,
:titulo) %># En el controlador:# auto_complete_for :curso, :titulo<%= url_for(:action => ’show’, :id => 4) %><%= excerpt("Hola, mundo, ¿que tal?", "mundo", 3) %><%= sanitize("<form> literal <a onbla=’se borra’>") %><%= textilize("Formato _simple_.\n\nCon parrafos") %><%= highlight("Resalto como Google", "Google") %>
Helpers: ejemplos
<%= text_field(:curso, :titulo) %><%= text_area(:curso, :observaciones, :rows => 10) %><%= pagination_links(paginador_cursos) %><%= text_field_with_auto_complete_field(:curso,
:titulo) %># En el controlador:# auto_complete_for :curso, :titulo<%= url_for(:action => ’show’, :id => 4) %><%= excerpt("Hola, mundo, ¿que tal?", "mundo", 3) %><%= sanitize("<form> literal <a onbla=’se borra’>") %><%= textilize("Formato _simple_.\n\nCon parrafos") %><%= highlight("Resalto como Google", "Google") %>
Helpers: ejemplos
<%= text_field(:curso, :titulo) %><%= text_area(:curso, :observaciones, :rows => 10) %><%= pagination_links(paginador_cursos) %><%= text_field_with_auto_complete_field(:curso,
:titulo) %># En el controlador:# auto_complete_for :curso, :titulo<%= url_for(:action => ’show’, :id => 4) %><%= excerpt("Hola, mundo, ¿que tal?", "mundo", 3) %><%= sanitize("<form> literal <a onbla=’se borra’>") %><%= textilize("Formato _simple_.\n\nCon parrafos") %><%= highlight("Resalto como Google", "Google") %>
Helpers: ejemplos
<%= text_field(:curso, :titulo) %><%= text_area(:curso, :observaciones, :rows => 10) %><%= pagination_links(paginador_cursos) %><%= text_field_with_auto_complete_field(:curso,
:titulo) %># En el controlador:# auto_complete_for :curso, :titulo<%= url_for(:action => ’show’, :id => 4) %><%= excerpt("Hola, mundo, ¿que tal?", "mundo", 3) %><%= sanitize("<form> literal <a onbla=’se borra’>") %><%= textilize("Formato _simple_.\n\nCon parrafos") %><%= highlight("Resalto como Google", "Google") %>
Helpers: ejemplos
<%= text_field(:curso, :titulo) %><%= text_area(:curso, :observaciones, :rows => 10) %><%= pagination_links(paginador_cursos) %><%= text_field_with_auto_complete_field(:curso,
:titulo) %># En el controlador:# auto_complete_for :curso, :titulo<%= url_for(:action => ’show’, :id => 4) %><%= excerpt("Hola, mundo, ¿que tal?", "mundo", 3) %><%= sanitize("<form> literal <a onbla=’se borra’>") %><%= textilize("Formato _simple_.\n\nCon parrafos") %><%= highlight("Resalto como Google", "Google") %>
Helpers: mas ejemplos
<%= human_size(1234567) # 1.2 MB %><%= number_to_percentage(302.0574, :precision => 2) %><%= number_with_delimiter(12345678) %><%= content_for("foo") do ... end %># En la plantilla general:# <%= @content_for_foo %><% benchmark "Parte difıcil" do %># Una parte difıcil que queremos medir
<% end %>
Helpers: mas ejemplos
<%= human_size(1234567) # 1.2 MB %><%= number_to_percentage(302.0574, :precision => 2) %><%= number_with_delimiter(12345678) %><%= content_for("foo") do ... end %># En la plantilla general:# <%= @content_for_foo %><% benchmark "Parte difıcil" do %># Una parte difıcil que queremos medir
<% end %>
Helpers: mas ejemplos
<%= human_size(1234567) # 1.2 MB %><%= number_to_percentage(302.0574, :precision => 2) %><%= number_with_delimiter(12345678) %><%= content_for("foo") do ... end %># En la plantilla general:# <%= @content_for_foo %><% benchmark "Parte difıcil" do %># Una parte difıcil que queremos medir
<% end %>
Helpers: mas ejemplos
<%= human_size(1234567) # 1.2 MB %><%= number_to_percentage(302.0574, :precision => 2) %><%= number_with_delimiter(12345678) %><%= content_for("foo") do ... end %># En la plantilla general:# <%= @content_for_foo %><% benchmark "Parte difıcil" do %># Una parte difıcil que queremos medir
<% end %>
Helpers: mas ejemplos
<%= human_size(1234567) # 1.2 MB %><%= number_to_percentage(302.0574, :precision => 2) %><%= number_with_delimiter(12345678) %><%= content_for("foo") do ... end %># En la plantilla general:# <%= @content_for_foo %><% benchmark "Parte difıcil" do %># Una parte difıcil que queremos medir
<% end %>
Helpers: mas ejemplos
<%= human_size(1234567) # 1.2 MB %><%= number_to_percentage(302.0574, :precision => 2) %><%= number_with_delimiter(12345678) %><%= content_for("foo") do ... end %># En la plantilla general:# <%= @content_for_foo %><% benchmark "Parte difıcil" do %># Una parte difıcil que queremos medir
<% end %>
Plantillas generales
• Permiten definir el aspecto base de las paginas
• Usan la variable @content for layout
• application.rhtml, controlador.rhtml (exclusivos)
• Ciertas acciones pueden evitarlo, conrender :layout => false
• Se pueden especificar otras plantillas, con excepcioneslayout ’foo’, :except => :metodo
Plantillas generales
• Permiten definir el aspecto base de las paginas
• Usan la variable @content for layout
• application.rhtml, controlador.rhtml (exclusivos)
• Ciertas acciones pueden evitarlo, conrender :layout => false
• Se pueden especificar otras plantillas, con excepcioneslayout ’foo’, :except => :metodo
Plantillas generales
• Permiten definir el aspecto base de las paginas
• Usan la variable @content for layout
• application.rhtml, controlador.rhtml (exclusivos)
• Ciertas acciones pueden evitarlo, conrender :layout => false
• Se pueden especificar otras plantillas, con excepcioneslayout ’foo’, :except => :metodo
Plantillas generales
• Permiten definir el aspecto base de las paginas
• Usan la variable @content for layout
• application.rhtml, controlador.rhtml (exclusivos)
• Ciertas acciones pueden evitarlo, conrender :layout => false
• Se pueden especificar otras plantillas, con excepcioneslayout ’foo’, :except => :metodo
Plantillas generales
• Permiten definir el aspecto base de las paginas
• Usan la variable @content for layout
• application.rhtml, controlador.rhtml (exclusivos)
• Ciertas acciones pueden evitarlo, conrender :layout => false
• Se pueden especificar otras plantillas, con excepcioneslayout ’foo’, :except => :metodo
Plantillas parciales
• Para reutilizar trozos de plantillas
• Empiezan por (( )), para no confundirlas con las otras
• Caso comun: asociadas a un modelo
• Para el modelo foo:
• Fichero: foo.rhtml• Se pasa el valor @foo• Dentro de la plantilla, variable local foo• Llamada ((base)): render(:partial, ’foo’)
Plantillas parciales
• Para reutilizar trozos de plantillas
• Empiezan por (( )), para no confundirlas con las otras
• Caso comun: asociadas a un modelo
• Para el modelo foo:
• Fichero: foo.rhtml• Se pasa el valor @foo• Dentro de la plantilla, variable local foo• Llamada ((base)): render(:partial, ’foo’)
Plantillas parciales
• Para reutilizar trozos de plantillas
• Empiezan por (( )), para no confundirlas con las otras
• Caso comun: asociadas a un modelo
• Para el modelo foo:
• Fichero: foo.rhtml• Se pasa el valor @foo• Dentro de la plantilla, variable local foo• Llamada ((base)): render(:partial, ’foo’)
Plantillas parciales
• Para reutilizar trozos de plantillas
• Empiezan por (( )), para no confundirlas con las otras
• Caso comun: asociadas a un modelo
• Para el modelo foo:
• Fichero: foo.rhtml• Se pasa el valor @foo• Dentro de la plantilla, variable local foo• Llamada ((base)): render(:partial, ’foo’)
Plantillas parciales
• Para reutilizar trozos de plantillas
• Empiezan por (( )), para no confundirlas con las otras
• Caso comun: asociadas a un modelo
• Para el modelo foo:• Fichero: foo.rhtml
• Se pasa el valor @foo• Dentro de la plantilla, variable local foo• Llamada ((base)): render(:partial, ’foo’)
Plantillas parciales
• Para reutilizar trozos de plantillas
• Empiezan por (( )), para no confundirlas con las otras
• Caso comun: asociadas a un modelo
• Para el modelo foo:• Fichero: foo.rhtml• Se pasa el valor @foo
• Dentro de la plantilla, variable local foo• Llamada ((base)): render(:partial, ’foo’)
Plantillas parciales
• Para reutilizar trozos de plantillas
• Empiezan por (( )), para no confundirlas con las otras
• Caso comun: asociadas a un modelo
• Para el modelo foo:• Fichero: foo.rhtml• Se pasa el valor @foo• Dentro de la plantilla, variable local foo
• Llamada ((base)): render(:partial, ’foo’)
Plantillas parciales
• Para reutilizar trozos de plantillas
• Empiezan por (( )), para no confundirlas con las otras
• Caso comun: asociadas a un modelo
• Para el modelo foo:• Fichero: foo.rhtml• Se pasa el valor @foo• Dentro de la plantilla, variable local foo• Llamada ((base)): render(:partial, ’foo’)
Indice
1 MVCModeloVistaControlador
2 Facilidades adicionalesEntornosActionMailerExtensiones al lenguaje
3 ConclusionesLo bueno/lo maloConsejos varios
El metodo render
• render(:text => ’Texto de demostracion’)
• render(:action => ’metodo’)
• render(:partial => ’p’, :locals => {:foo => 1})• render(:partial => ’p’, :collection => @lista)
• render(:partial => ’p’, :collection => @lista,:spacer template => ’division’)
• render(:file => ’shared/p’)
• render(:inline => ’< %= dentro de dentro de %>’)
• render(:nothing => true)
El metodo render
• render(:text => ’Texto de demostracion’)
• render(:action => ’metodo’)
• render(:partial => ’p’, :locals => {:foo => 1})• render(:partial => ’p’, :collection => @lista)
• render(:partial => ’p’, :collection => @lista,:spacer template => ’division’)
• render(:file => ’shared/p’)
• render(:inline => ’< %= dentro de dentro de %>’)
• render(:nothing => true)
El metodo render
• render(:text => ’Texto de demostracion’)
• render(:action => ’metodo’)
• render(:partial => ’p’, :locals => {:foo => 1})
• render(:partial => ’p’, :collection => @lista)
• render(:partial => ’p’, :collection => @lista,:spacer template => ’division’)
• render(:file => ’shared/p’)
• render(:inline => ’< %= dentro de dentro de %>’)
• render(:nothing => true)
El metodo render
• render(:text => ’Texto de demostracion’)
• render(:action => ’metodo’)
• render(:partial => ’p’, :locals => {:foo => 1})• render(:partial => ’p’, :collection => @lista)
• render(:partial => ’p’, :collection => @lista,:spacer template => ’division’)
• render(:file => ’shared/p’)
• render(:inline => ’< %= dentro de dentro de %>’)
• render(:nothing => true)
El metodo render
• render(:text => ’Texto de demostracion’)
• render(:action => ’metodo’)
• render(:partial => ’p’, :locals => {:foo => 1})• render(:partial => ’p’, :collection => @lista)
• render(:partial => ’p’, :collection => @lista,:spacer template => ’division’)
• render(:file => ’shared/p’)
• render(:inline => ’< %= dentro de dentro de %>’)
• render(:nothing => true)
El metodo render
• render(:text => ’Texto de demostracion’)
• render(:action => ’metodo’)
• render(:partial => ’p’, :locals => {:foo => 1})• render(:partial => ’p’, :collection => @lista)
• render(:partial => ’p’, :collection => @lista,:spacer template => ’division’)
• render(:file => ’shared/p’)
• render(:inline => ’< %= dentro de dentro de %>’)
• render(:nothing => true)
El metodo render
• render(:text => ’Texto de demostracion’)
• render(:action => ’metodo’)
• render(:partial => ’p’, :locals => {:foo => 1})• render(:partial => ’p’, :collection => @lista)
• render(:partial => ’p’, :collection => @lista,:spacer template => ’division’)
• render(:file => ’shared/p’)
• render(:inline => ’< %= dentro de dentro de %>’)
• render(:nothing => true)
El metodo render
• render(:text => ’Texto de demostracion’)
• render(:action => ’metodo’)
• render(:partial => ’p’, :locals => {:foo => 1})• render(:partial => ’p’, :collection => @lista)
• render(:partial => ’p’, :collection => @lista,:spacer template => ’division’)
• render(:file => ’shared/p’)
• render(:inline => ’< %= dentro de dentro de %>’)
• render(:nothing => true)
Otros metodos
• redirect to(:action => ’foo’)
• redirect to(’http://www.foo.com’)
• flash[:notice] = ’Mensaje’(Plantilla → flash[:notice])
• send file(:filename => ..., :disposition => ...)
• send data(:filename => ..., :disposition => ...)
Otros metodos
• redirect to(:action => ’foo’)
• redirect to(’http://www.foo.com’)
• flash[:notice] = ’Mensaje’(Plantilla → flash[:notice])
• send file(:filename => ..., :disposition => ...)
• send data(:filename => ..., :disposition => ...)
Otros metodos
• redirect to(:action => ’foo’)
• redirect to(’http://www.foo.com’)
• flash[:notice] = ’Mensaje’(Plantilla → flash[:notice])
• send file(:filename => ..., :disposition => ...)
• send data(:filename => ..., :disposition => ...)
Otros metodos
• redirect to(:action => ’foo’)
• redirect to(’http://www.foo.com’)
• flash[:notice] = ’Mensaje’(Plantilla → flash[:notice])
• send file(:filename => ..., :disposition => ...)
• send data(:filename => ..., :disposition => ...)
Otros metodos
• redirect to(:action => ’foo’)
• redirect to(’http://www.foo.com’)
• flash[:notice] = ’Mensaje’(Plantilla → flash[:notice])
• send file(:filename => ..., :disposition => ...)
• send data(:filename => ..., :disposition => ...)
Filtros
• Permiten ejecutar codigo antes/despues de las acciones
• Permiten saltarse las propias ejecuciones de las acciones
• Muy utiles para autenticacion y para filtrado posterior
• Tres tipos:
• before filter• after filter• around filter
• Tres declaraciones:
• Sımbolo• Objeto Proc (bloque)• Clase
Filtros
• Permiten ejecutar codigo antes/despues de las acciones
• Permiten saltarse las propias ejecuciones de las acciones
• Muy utiles para autenticacion y para filtrado posterior
• Tres tipos:
• before filter• after filter• around filter
• Tres declaraciones:
• Sımbolo• Objeto Proc (bloque)• Clase
Filtros
• Permiten ejecutar codigo antes/despues de las acciones
• Permiten saltarse las propias ejecuciones de las acciones
• Muy utiles para autenticacion y para filtrado posterior
• Tres tipos:
• before filter• after filter• around filter
• Tres declaraciones:
• Sımbolo• Objeto Proc (bloque)• Clase
Filtros
• Permiten ejecutar codigo antes/despues de las acciones
• Permiten saltarse las propias ejecuciones de las acciones
• Muy utiles para autenticacion y para filtrado posterior
• Tres tipos:
• before filter• after filter• around filter
• Tres declaraciones:
• Sımbolo• Objeto Proc (bloque)• Clase
Filtros
• Permiten ejecutar codigo antes/despues de las acciones
• Permiten saltarse las propias ejecuciones de las acciones
• Muy utiles para autenticacion y para filtrado posterior
• Tres tipos:• before filter
• after filter• around filter
• Tres declaraciones:
• Sımbolo• Objeto Proc (bloque)• Clase
Filtros
• Permiten ejecutar codigo antes/despues de las acciones
• Permiten saltarse las propias ejecuciones de las acciones
• Muy utiles para autenticacion y para filtrado posterior
• Tres tipos:• before filter• after filter
• around filter
• Tres declaraciones:
• Sımbolo• Objeto Proc (bloque)• Clase
Filtros
• Permiten ejecutar codigo antes/despues de las acciones
• Permiten saltarse las propias ejecuciones de las acciones
• Muy utiles para autenticacion y para filtrado posterior
• Tres tipos:• before filter• after filter• around filter
• Tres declaraciones:
• Sımbolo• Objeto Proc (bloque)• Clase
Filtros
• Permiten ejecutar codigo antes/despues de las acciones
• Permiten saltarse las propias ejecuciones de las acciones
• Muy utiles para autenticacion y para filtrado posterior
• Tres tipos:• before filter• after filter• around filter
• Tres declaraciones:
• Sımbolo• Objeto Proc (bloque)• Clase
Filtros
• Permiten ejecutar codigo antes/despues de las acciones
• Permiten saltarse las propias ejecuciones de las acciones
• Muy utiles para autenticacion y para filtrado posterior
• Tres tipos:• before filter• after filter• around filter
• Tres declaraciones:• Sımbolo
• Objeto Proc (bloque)• Clase
Filtros
• Permiten ejecutar codigo antes/despues de las acciones
• Permiten saltarse las propias ejecuciones de las acciones
• Muy utiles para autenticacion y para filtrado posterior
• Tres tipos:• before filter• after filter• around filter
• Tres declaraciones:• Sımbolo• Objeto Proc (bloque)
• Clase
Filtros
• Permiten ejecutar codigo antes/despues de las acciones
• Permiten saltarse las propias ejecuciones de las acciones
• Muy utiles para autenticacion y para filtrado posterior
• Tres tipos:• before filter• after filter• around filter
• Tres declaraciones:• Sımbolo• Objeto Proc (bloque)• Clase
Filtros: ejemplos
class FooController < ActionController::Basebefore_filter :usuarioafter_filter {|cont| Auditoria.registrar(...)}
def usuarioreturn usuario_conectado == ’yo’
endend
Filtros: ejemplos
class FooController < ActionController::Basebefore_filter :usuarioafter_filter {|cont| Auditoria.registrar(...)}
def usuarioreturn usuario_conectado == ’yo’
endend
Filtros: ejemplos
class FooController < ActionController::Basebefore_filter :usuarioafter_filter {|cont| Auditoria.registrar(...)}
def usuarioreturn usuario_conectado == ’yo’
endend
Filtros: ejemplo de around filter
class Filtrodef before; ...; enddef after; ...; end
end
class FooController < ActionController::Basearound_filter Filtro.new
end
Filtros: ejemplo de around filter
class Filtrodef before; ...; enddef after; ...; end
end
class FooController < ActionController::Basearound_filter Filtro.new
end
Filtros: ejemplo de around filter
class Filtrodef before; ...; enddef after; ...; end
end
class FooController < ActionController::Basearound_filter Filtro.new
end
Indice
1 MVCModeloVistaControlador
2 Facilidades adicionalesEntornosActionMailerExtensiones al lenguaje
3 ConclusionesLo bueno/lo maloConsejos varios
Descripcion
• Diferentes entornos de configuracion
• Permiten adaptar la aplicacion al entorno:
• Datos de conexion a la base de datos• Valores de configuracion
• development, production, test
• Definidos en config/environments/entorno.rb
Descripcion
• Diferentes entornos de configuracion
• Permiten adaptar la aplicacion al entorno:
• Datos de conexion a la base de datos• Valores de configuracion
• development, production, test
• Definidos en config/environments/entorno.rb
Descripcion
• Diferentes entornos de configuracion
• Permiten adaptar la aplicacion al entorno:• Datos de conexion a la base de datos
• Valores de configuracion
• development, production, test
• Definidos en config/environments/entorno.rb
Descripcion
• Diferentes entornos de configuracion
• Permiten adaptar la aplicacion al entorno:• Datos de conexion a la base de datos• Valores de configuracion
• development, production, test
• Definidos en config/environments/entorno.rb
Descripcion
• Diferentes entornos de configuracion
• Permiten adaptar la aplicacion al entorno:• Datos de conexion a la base de datos• Valores de configuracion
• development, production, test
• Definidos en config/environments/entorno.rb
Descripcion
• Diferentes entornos de configuracion
• Permiten adaptar la aplicacion al entorno:• Datos de conexion a la base de datos• Valores de configuracion
• development, production, test
• Definidos en config/environments/entorno.rb
Indice
1 MVCModeloVistaControlador
2 Facilidades adicionalesEntornosActionMailerExtensiones al lenguaje
3 ConclusionesLo bueno/lo maloConsejos varios
Descripcion
• Permite mandar correo facilmente
• Usa plantillas, igual que las vistas
• La configuracion ((viene dada))
• Definimos ((carteros)) (clases ActionMailer), y metodos
• Definimos los metodos que/como queramos (¡importante!)
• Muy natural y sencillo, siempre dentro del dominio
• Se usa como Cartero.deliver accion(...)
• Carteros → app/models/cartero.rb
• Plantillas → app/views/cartero/accion.rhtml
Descripcion
• Permite mandar correo facilmente
• Usa plantillas, igual que las vistas
• La configuracion ((viene dada))
• Definimos ((carteros)) (clases ActionMailer), y metodos
• Definimos los metodos que/como queramos (¡importante!)
• Muy natural y sencillo, siempre dentro del dominio
• Se usa como Cartero.deliver accion(...)
• Carteros → app/models/cartero.rb
• Plantillas → app/views/cartero/accion.rhtml
Descripcion
• Permite mandar correo facilmente
• Usa plantillas, igual que las vistas
• La configuracion ((viene dada))
• Definimos ((carteros)) (clases ActionMailer), y metodos
• Definimos los metodos que/como queramos (¡importante!)
• Muy natural y sencillo, siempre dentro del dominio
• Se usa como Cartero.deliver accion(...)
• Carteros → app/models/cartero.rb
• Plantillas → app/views/cartero/accion.rhtml
Descripcion
• Permite mandar correo facilmente
• Usa plantillas, igual que las vistas
• La configuracion ((viene dada))
• Definimos ((carteros)) (clases ActionMailer), y metodos
• Definimos los metodos que/como queramos (¡importante!)
• Muy natural y sencillo, siempre dentro del dominio
• Se usa como Cartero.deliver accion(...)
• Carteros → app/models/cartero.rb
• Plantillas → app/views/cartero/accion.rhtml
Descripcion
• Permite mandar correo facilmente
• Usa plantillas, igual que las vistas
• La configuracion ((viene dada))
• Definimos ((carteros)) (clases ActionMailer), y metodos
• Definimos los metodos que/como queramos (¡importante!)
• Muy natural y sencillo, siempre dentro del dominio
• Se usa como Cartero.deliver accion(...)
• Carteros → app/models/cartero.rb
• Plantillas → app/views/cartero/accion.rhtml
Descripcion
• Permite mandar correo facilmente
• Usa plantillas, igual que las vistas
• La configuracion ((viene dada))
• Definimos ((carteros)) (clases ActionMailer), y metodos
• Definimos los metodos que/como queramos (¡importante!)
• Muy natural y sencillo, siempre dentro del dominio
• Se usa como Cartero.deliver accion(...)
• Carteros → app/models/cartero.rb
• Plantillas → app/views/cartero/accion.rhtml
Descripcion
• Permite mandar correo facilmente
• Usa plantillas, igual que las vistas
• La configuracion ((viene dada))
• Definimos ((carteros)) (clases ActionMailer), y metodos
• Definimos los metodos que/como queramos (¡importante!)
• Muy natural y sencillo, siempre dentro del dominio
• Se usa como Cartero.deliver accion(...)
• Carteros → app/models/cartero.rb
• Plantillas → app/views/cartero/accion.rhtml
Descripcion
• Permite mandar correo facilmente
• Usa plantillas, igual que las vistas
• La configuracion ((viene dada))
• Definimos ((carteros)) (clases ActionMailer), y metodos
• Definimos los metodos que/como queramos (¡importante!)
• Muy natural y sencillo, siempre dentro del dominio
• Se usa como Cartero.deliver accion(...)
• Carteros → app/models/cartero.rb
• Plantillas → app/views/cartero/accion.rhtml
Descripcion
• Permite mandar correo facilmente
• Usa plantillas, igual que las vistas
• La configuracion ((viene dada))
• Definimos ((carteros)) (clases ActionMailer), y metodos
• Definimos los metodos que/como queramos (¡importante!)
• Muy natural y sencillo, siempre dentro del dominio
• Se usa como Cartero.deliver accion(...)
• Carteros → app/models/cartero.rb
• Plantillas → app/views/cartero/accion.rhtml
ActionMailer: ejemplo
class AvisosIntranet < ActionMailer::Basedef nueva_pregunta(pregunta)@recipients = Empleado.map {|e| e.direccion}.
join(", ")@from = DIRECCION_REMITENTE@subject = "Nueva pregunta: #{pregunta.enunciado}"
# Contenido@body[:enunciado] = pregunta.enunciado@body[:respuesta] = pregunta.respuesta@body[:autor] = pregunta.autor.nombre@body[:fecha] = pregunta.fecha_alta
endend
ActionMailer: ejemplo
class AvisosIntranet < ActionMailer::Basedef nueva_pregunta(pregunta)@recipients = Empleado.map {|e| e.direccion}.
join(", ")@from = DIRECCION_REMITENTE@subject = "Nueva pregunta: #{pregunta.enunciado}"
# Contenido@body[:enunciado] = pregunta.enunciado@body[:respuesta] = pregunta.respuesta@body[:autor] = pregunta.autor.nombre@body[:fecha] = pregunta.fecha_alta
endend
ActionMailer: ejemplo
class AvisosIntranet < ActionMailer::Basedef nueva_pregunta(pregunta)@recipients = Empleado.map {|e| e.direccion}.
join(", ")@from = DIRECCION_REMITENTE@subject = "Nueva pregunta: #{pregunta.enunciado}"
# Contenido@body[:enunciado] = pregunta.enunciado@body[:respuesta] = pregunta.respuesta@body[:autor] = pregunta.autor.nombre@body[:fecha] = pregunta.fecha_alta
endend
ActionMailer: ejemplo
class AvisosIntranet < ActionMailer::Basedef nueva_pregunta(pregunta)@recipients = Empleado.map {|e| e.direccion}.
join(", ")@from = DIRECCION_REMITENTE@subject = "Nueva pregunta: #{pregunta.enunciado}"
# Contenido@body[:enunciado] = pregunta.enunciado@body[:respuesta] = pregunta.respuesta@body[:autor] = pregunta.autor.nombre@body[:fecha] = pregunta.fecha_alta
endend
ActionMailer: ejemplo
class AvisosIntranet < ActionMailer::Basedef nueva_pregunta(pregunta)@recipients = Empleado.map {|e| e.direccion}.
join(", ")@from = DIRECCION_REMITENTE@subject = "Nueva pregunta: #{pregunta.enunciado}"
# Contenido@body[:enunciado] = pregunta.enunciado@body[:respuesta] = pregunta.respuesta@body[:autor] = pregunta.autor.nombre@body[:fecha] = pregunta.fecha_alta
endend
ActionMailer: ejemplo
class AvisosIntranet < ActionMailer::Basedef nueva_pregunta(pregunta)@recipients = Empleado.map {|e| e.direccion}.
join(", ")@from = DIRECCION_REMITENTE@subject = "Nueva pregunta: #{pregunta.enunciado}"
# Contenido@body[:enunciado] = pregunta.enunciado@body[:respuesta] = pregunta.respuesta@body[:autor] = pregunta.autor.nombre@body[:fecha] = pregunta.fecha_alta
endend
ActionMailer: ejemplo
class AvisosIntranet < ActionMailer::Basedef nueva_pregunta(pregunta)@recipients = Empleado.map {|e| e.direccion}.
join(", ")@from = DIRECCION_REMITENTE@subject = "Nueva pregunta: #{pregunta.enunciado}"
# Contenido@body[:enunciado] = pregunta.enunciado@body[:respuesta] = pregunta.respuesta@body[:autor] = pregunta.autor.nombre@body[:fecha] = pregunta.fecha_alta
endend
ActionMailer: ejemplo
class AvisosIntranet < ActionMailer::Basedef nueva_pregunta(pregunta)@recipients = Empleado.map {|e| e.direccion}.
join(", ")@from = DIRECCION_REMITENTE@subject = "Nueva pregunta: #{pregunta.enunciado}"
# Contenido@body[:enunciado] = pregunta.enunciado@body[:respuesta] = pregunta.respuesta@body[:autor] = pregunta.autor.nombre@body[:fecha] = pregunta.fecha_alta
endend
ActionMailer: ejemplo
class AvisosIntranet < ActionMailer::Basedef nueva_pregunta(pregunta)@recipients = Empleado.map {|e| e.direccion}.
join(", ")@from = DIRECCION_REMITENTE@subject = "Nueva pregunta: #{pregunta.enunciado}"
# Contenido@body[:enunciado] = pregunta.enunciado@body[:respuesta] = pregunta.respuesta@body[:autor] = pregunta.autor.nombre@body[:fecha] = pregunta.fecha_alta
endend
ActionMailer: ejemplo de plantilla
# app/views/avisos_intranet/nueva_pregunta.rhtml<%= @autor %> ha a~nadido una nueva preguntaa la Intranet el dıa <%= @fecha %>:
<%= @enunciado %>-----------------<%= @respuesta %>
ActionMailer: ejemplo de configuracion
# Extracto de config/environments/production.rb, p.ej.
ActionMailer::Base.server_settings =:address => ’smtp.empresa.com’,:port => ’25’,:user_name => ’user’,:password => ’pass’,:authentication => :plain
ActionMailer::Base.delivery_method = :smtp
Indice
1 MVCModeloVistaControlador
2 Facilidades adicionalesEntornosActionMailerExtensiones al lenguaje
3 ConclusionesLo bueno/lo maloConsejos varios
Otros
• String#camelcase, String#humanize
• Array#to sentence
• Hash#stringify keys
• Time#end of month, Time#next year
Otros
• String#camelcase, String#humanize
• Array#to sentence
• Hash#stringify keys
• Time#end of month, Time#next year
Otros
• String#camelcase, String#humanize
• Array#to sentence
• Hash#stringify keys
• Time#end of month, Time#next year
Otros
• String#camelcase, String#humanize
• Array#to sentence
• Hash#stringify keys
• Time#end of month, Time#next year
Indice
1 MVCModeloVistaControlador
2 Facilidades adicionalesEntornosActionMailerExtensiones al lenguaje
3 ConclusionesLo bueno/lo maloConsejos varios
Lo bueno
• Basado en un lenguaje dinamico y potente
• Esta de moda (comunidad, esfuerzos)
• Caso comun muy sencillo...
• ...manteniendo la flexibilidad
• Solo estamos en la 1.0
Lo bueno
• Basado en un lenguaje dinamico y potente
• Esta de moda (comunidad, esfuerzos)
• Caso comun muy sencillo...
• ...manteniendo la flexibilidad
• Solo estamos en la 1.0
Lo bueno
• Basado en un lenguaje dinamico y potente
• Esta de moda (comunidad, esfuerzos)
• Caso comun muy sencillo...
• ...manteniendo la flexibilidad
• Solo estamos en la 1.0
Lo bueno
• Basado en un lenguaje dinamico y potente
• Esta de moda (comunidad, esfuerzos)
• Caso comun muy sencillo...
• ...manteniendo la flexibilidad
• Solo estamos en la 1.0
Lo bueno
• Basado en un lenguaje dinamico y potente
• Esta de moda (comunidad, esfuerzos)
• Caso comun muy sencillo...
• ...manteniendo la flexibilidad
• Solo estamos en la 1.0
Lo malo
• Codigo generado para tablas no convencionales
• ActiveRecord no funciona con tablas de clave multiple
• Anglo-centrismo (buscar traducciones)
• Algunas incompatibilidades entre versiones
• Menos cuidado y empuje con las bases de datos no libres
Lo malo
• Codigo generado para tablas no convencionales
• ActiveRecord no funciona con tablas de clave multiple
• Anglo-centrismo (buscar traducciones)
• Algunas incompatibilidades entre versiones
• Menos cuidado y empuje con las bases de datos no libres
Lo malo
• Codigo generado para tablas no convencionales
• ActiveRecord no funciona con tablas de clave multiple
• Anglo-centrismo (buscar traducciones)
• Algunas incompatibilidades entre versiones
• Menos cuidado y empuje con las bases de datos no libres
Lo malo
• Codigo generado para tablas no convencionales
• ActiveRecord no funciona con tablas de clave multiple
• Anglo-centrismo (buscar traducciones)
• Algunas incompatibilidades entre versiones
• Menos cuidado y empuje con las bases de datos no libres
Lo malo
• Codigo generado para tablas no convencionales
• ActiveRecord no funciona con tablas de clave multiple
• Anglo-centrismo (buscar traducciones)
• Algunas incompatibilidades entre versiones
• Menos cuidado y empuje con las bases de datos no libres
Indice
1 MVCModeloVistaControlador
2 Facilidades adicionalesEntornosActionMailerExtensiones al lenguaje
3 ConclusionesLo bueno/lo maloConsejos varios
Base de datos
• Usar las convenciones de Rails
• Declarar y usar las relaciones entre modelos
• Explotar ActiveRecord (mirar la documentacion)
• Enriquecer los modelos con nuevos metodos
• Usar mucho la consola para hacer pruebas
Base de datos
• Usar las convenciones de Rails
• Declarar y usar las relaciones entre modelos
• Explotar ActiveRecord (mirar la documentacion)
• Enriquecer los modelos con nuevos metodos
• Usar mucho la consola para hacer pruebas
Base de datos
• Usar las convenciones de Rails
• Declarar y usar las relaciones entre modelos
• Explotar ActiveRecord (mirar la documentacion)
• Enriquecer los modelos con nuevos metodos
• Usar mucho la consola para hacer pruebas
Base de datos
• Usar las convenciones de Rails
• Declarar y usar las relaciones entre modelos
• Explotar ActiveRecord (mirar la documentacion)
• Enriquecer los modelos con nuevos metodos
• Usar mucho la consola para hacer pruebas
Base de datos
• Usar las convenciones de Rails
• Declarar y usar las relaciones entre modelos
• Explotar ActiveRecord (mirar la documentacion)
• Enriquecer los modelos con nuevos metodos
• Usar mucho la consola para hacer pruebas
En general
• Escribir helpers para cualquier cosa
• Usar parciales para los trozos repetibles de HTML
• Mirar la documentacion (http://api.rubyonrails.org)
• Familiarizarse con algunos de los efectos de Prototype
• Consultar http://wiki.rubyonrails.org
• No actualizar Rails alegremente
• Aprender Ruby bien, para aprovechar su potencia
En general
• Escribir helpers para cualquier cosa
• Usar parciales para los trozos repetibles de HTML
• Mirar la documentacion (http://api.rubyonrails.org)
• Familiarizarse con algunos de los efectos de Prototype
• Consultar http://wiki.rubyonrails.org
• No actualizar Rails alegremente
• Aprender Ruby bien, para aprovechar su potencia
En general
• Escribir helpers para cualquier cosa
• Usar parciales para los trozos repetibles de HTML
• Mirar la documentacion (http://api.rubyonrails.org)
• Familiarizarse con algunos de los efectos de Prototype
• Consultar http://wiki.rubyonrails.org
• No actualizar Rails alegremente
• Aprender Ruby bien, para aprovechar su potencia
En general
• Escribir helpers para cualquier cosa
• Usar parciales para los trozos repetibles de HTML
• Mirar la documentacion (http://api.rubyonrails.org)
• Familiarizarse con algunos de los efectos de Prototype
• Consultar http://wiki.rubyonrails.org
• No actualizar Rails alegremente
• Aprender Ruby bien, para aprovechar su potencia
En general
• Escribir helpers para cualquier cosa
• Usar parciales para los trozos repetibles de HTML
• Mirar la documentacion (http://api.rubyonrails.org)
• Familiarizarse con algunos de los efectos de Prototype
• Consultar http://wiki.rubyonrails.org
• No actualizar Rails alegremente
• Aprender Ruby bien, para aprovechar su potencia
En general
• Escribir helpers para cualquier cosa
• Usar parciales para los trozos repetibles de HTML
• Mirar la documentacion (http://api.rubyonrails.org)
• Familiarizarse con algunos de los efectos de Prototype
• Consultar http://wiki.rubyonrails.org
• No actualizar Rails alegremente
• Aprender Ruby bien, para aprovechar su potencia
En general
• Escribir helpers para cualquier cosa
• Usar parciales para los trozos repetibles de HTML
• Mirar la documentacion (http://api.rubyonrails.org)
• Familiarizarse con algunos de los efectos de Prototype
• Consultar http://wiki.rubyonrails.org
• No actualizar Rails alegremente
• Aprender Ruby bien, para aprovechar su potencia
top related