2010-09-21 06:45:05 +00:00
= Sinatra
2010-09-22 05:50:09 +00:00
<i>Atención: Este documento es una traducción de la versión en inglés y puede estar desactualizado.</i>
2010-09-21 06:45:05 +00:00
2010-09-21 02:13:40 +00:00
Sinatra es un DSL para crear aplicaciones web rápidamente en Ruby con un mínimo
esfuerzo:
2010-09-21 06:45:05 +00:00
# miapp.rb
require 'sinatra'
2010-09-30 19:12:21 +00:00
2010-09-21 06:45:05 +00:00
get '/' do
'Hola mundo!'
end
2010-09-21 02:13:40 +00:00
Instalá la gem y ejecutá la aplicación con:
2010-09-21 06:45:05 +00:00
2010-09-21 06:57:26 +00:00
gem install sinatra
ruby -rubygems miapp.rb
2010-09-21 06:45:05 +00:00
Podés verla en: http://localhost:4567
2011-02-21 21:06:42 +00:00
Es recomendable además ejecutar <tt>gem install thin</tt>, ya que Sinatra lo va
a utilizar cuando esté disponible.
2010-09-21 06:45:05 +00:00
== Rutas
2010-09-21 02:13:40 +00:00
En Sinatra, una ruta está compuesta por un método HTTP y un patrón de una URL.
Cada ruta se asocia con un bloque:
2010-09-21 06:45:05 +00:00
get '/' do
.. mostrar algo ..
end
post '/' do
.. crear algo ..
end
put '/' do
2011-03-20 17:49:48 +00:00
.. reemplazar algo ..
end
patch '/' do
.. modificar algo ..
2010-09-21 06:45:05 +00:00
end
delete '/' do
.. aniquilar algo ..
end
2010-12-20 16:04:20 +00:00
options '/' do
.. informar algo ..
end
2010-09-21 06:45:05 +00:00
Las rutas son comparadas en el orden en el que son definidas. La primer ruta
que coincide con la petición es invocada.
Los patrones de las rutas pueden incluir parámetros nombrados, accesibles a
través de el hash <tt>params</tt>:
get '/hola/:nombre' do
# coincide con "GET /hola/foo" y "GET /hola/bar"
2010-09-21 02:13:40 +00:00
# params[:nombre] es 'foo' o 'bar'
2010-09-21 06:45:05 +00:00
"Hola #{params[:nombre]}!"
end
También podés acceder a los parámetros nombrados usando parámetros de bloque:
get '/hola/:nombre' do |n|
"Hola #{n}!"
end
2010-09-21 02:13:40 +00:00
Los patrones de ruta también pueden incluir parámetros splat (o wildcard),
2011-03-09 00:12:32 +00:00
accesibles a través del arreglo <tt>params[:splat]</tt>:
2010-09-21 06:45:05 +00:00
get '/decir/*/al/*' do
# coincide con /decir/hola/al/mundo
params[:splat] # => ["hola", "mundo"]
end
get '/descargar/*.*' do
# coincide con /descargar/path/al/archivo.xml
params[:splat] # => ["path/al/archivo", "xml"]
end
2011-05-23 21:06:58 +00:00
O, con parámetros de bloque:
get '/descargar/*.*' do |path, ext|
[path, ext] # => ["path/al/archivo", "xml"]
end
2010-09-21 02:13:40 +00:00
Rutas con Expresiones Regulares:
2010-09-21 06:45:05 +00:00
get %r{/hola/([\w]+)} do
"Hola, #{params[:captures].first}!"
end
O con un parámetro de bloque:
get %r{/hola/([\w]+)} do |c|
"Hola, #{c}!"
end
2011-07-31 22:38:51 +00:00
Los patrones de ruta pueden contener parámetros opcionales:
get '/posts.?:formato?' do
# coincide con "GET /posts" y además admite cualquier extensión, por
# ejemplo, "GET /posts.json", "GET /posts.xml", etc.
end
2011-09-05 00:47:01 +00:00
A propósito, a menos que desactivés la protección para el ataque <em>path
traversal</em> (ver más abajo), el path de la petición puede ser modificado
antes de que se compare con los de tus rutas.
2010-09-30 19:12:21 +00:00
=== Condiciones
2010-09-21 06:45:05 +00:00
Las rutas pueden incluir una variedad de condiciones de selección, como por
2010-09-21 02:13:40 +00:00
ejemplo el user agent:
2010-09-21 06:45:05 +00:00
get '/foo', :agent => /Songbird (\d\.\d)[\d\/]*?/ do
2010-09-21 02:13:40 +00:00
"Estás usando la versión de Songbird #{params[:agent][0]}"
2010-09-21 06:45:05 +00:00
end
get '/foo' do
# Coincide con browsers que no sean songbird
end
2010-09-30 19:12:21 +00:00
Otras condiciones disponibles son +host_name+ y +provides+:
get '/', :host_name => /^admin\./ do
"Área de Administración, Acceso denegado!"
end
get '/', :provides => 'html' do
haml :index
end
get '/', :provides => ['rss', 'atom', 'xml'] do
builder :feed
end
Podés definir tus propias condiciones fácilmente:
set(:probabilidad) { |valor| condition { rand <= valor } }
get '/gana_un_auto', :probabilidad => 0.1 do
"Ganaste!"
end
get '/gana_un_auto' do
"Lo siento, perdiste."
end
2011-08-22 19:09:57 +00:00
Si tu condición acepta más de un argumento, podés pasarle un arreglo. Al
definir la condición puede resultarte conveniente utilizar el operador splat en
la lista de parámetros:
set(:autorizar) do |*roles| # <- mirá el splat
condition do
unless sesion_iniciada? && roles.any? {|rol| usuario_actual.tiene_rol? rol }
redirect "/iniciar_sesion/", 303
end
end
end
get "/mi/cuenta/", :autorizar => [:usuario, :administrador] do
"Detalles de mi cuenta"
end
get "/solo/administradores/", :autorizar => :administrador do
2011-08-22 20:08:57 +00:00
"Únicamente para administradores!"
2011-08-22 19:09:57 +00:00
end
2011-02-21 21:06:42 +00:00
=== Valores de Retorno
2010-09-30 19:12:21 +00:00
El valor de retorno de un bloque de ruta determina al menos el cuerpo de la
respuesta que se le pasa al cliente HTTP o al siguiente middleware en la pila
de Rack. Lo más común es que sea un string, como en los ejemplos anteriores.
Sin embargo, otros valor también son aceptados.
Podés devolver cualquier objeto que sea una respuesta Rack válida, un objeto
que represente el cuerpo de una respuesta Rack o un código de estado HTTP:
* Un arreglo con tres elementos: <tt>[estado (Fixnum), cabeceras (Hash), cuerpo de la respuesta (responde a #each)]</tt>
* Un arreglo con dos elementos: <tt>[estado (Fixnum), cuerpo de la respuesta (responde a #each)]</tt>
* Un objeto que responde a <tt>#each</tt> y que le pasa únicamente strings al bloque dado
* Un Fixnum representando el código de estado
De esa manera podemos, por ejemplo, implementar fácilmente un streaming:
class Stream
def each
100.times { |i| yield "#{i}\n" }
end
end
get('/') { Stream.new }
2011-02-21 21:06:42 +00:00
=== Comparadores de Rutas Personalizados
Como se mostró anteriormente, Sinatra permite utilizar Strings y expresiones
regulares para definir las rutas. Sin embargo, la cosa no termina ahí. Podés
definir tus propios comparadores muy fácilmente:
class PattronCualquieraMenos
Match = Struct.new(:captures)
def initialize(excepto)
@excepto = excepto
2011-03-09 00:12:32 +00:00
@capturas = Match.new([])
2011-02-21 21:06:42 +00:00
end
def match(str)
2011-03-09 00:12:32 +00:00
@capturas unless @excepto === str
2011-02-21 21:06:42 +00:00
end
end
def cualquiera_menos(patron)
PatronCualquieraMenos.new(patron)
end
get cualquiera_menos("/index") do
# ...
end
Tené en cuenta que el ejemplo anterior es un poco rebuscado. Un resultado
similar puede conseguirse más sencillamente:
get // do
pass if request.path_info == "/index"
# ...
end
O, usando un lookahead negativo:
get %r{^(?!/index$)} do
# ...
end
2011-01-12 23:05:26 +00:00
== Archivos Estáticos
2010-09-21 06:45:05 +00:00
Los archivos estáticos son servidos desde el directorio público
<tt>./public</tt>. Podés especificar una ubicación diferente ajustando la
2011-06-15 22:24:27 +00:00
opción <tt>:public_folder</tt>:
2010-09-21 06:45:05 +00:00
2011-06-15 22:24:27 +00:00
set :public_folder, File.dirname(__FILE__) + '/estaticos'
2010-09-21 06:45:05 +00:00
Notá que el nombre del directorio público no está incluido en la URL. Por
ejemplo, el archivo <tt>./public/css/style.css</tt> se accede a través de
<tt>http://ejemplo.com/css/style.css</tt>.
2011-06-12 16:09:37 +00:00
Usá la configuración <tt>:static_cache_control</tt> para agregar el encabezado
<tt>Cache-Control</tt> (ver la sección de configuración para más detalles).
2010-09-21 06:45:05 +00:00
== Vistas / Plantillas
2011-05-23 22:56:46 +00:00
Cada lenguaje de plantilla se expone a través de un método de renderizado que
lleva su nombre. Estos métodos simplemente devuelven un string:
2010-09-21 06:45:05 +00:00
get '/' do
2011-05-23 22:56:46 +00:00
erb :index
2010-09-21 06:45:05 +00:00
end
2011-05-23 22:56:46 +00:00
Renderiza <tt>views/index.erb</tt>.
2010-09-21 06:45:05 +00:00
2011-05-23 22:56:46 +00:00
En lugar del nombre de la plantilla podés proporcionar directamente el
contenido de la misma:
2010-09-21 06:45:05 +00:00
get '/' do
2011-05-23 22:56:46 +00:00
codigo = "<%= Time.now %>"
erb codigo
2010-09-21 06:45:05 +00:00
end
2011-05-23 22:56:46 +00:00
Los métodos de renderizado, aceptan además un segundo argumento, el hash de
opciones:
2010-09-21 06:45:05 +00:00
get '/' do
2011-05-23 22:56:46 +00:00
erb :index, :layout => :post
2010-09-21 06:45:05 +00:00
end
2011-05-23 22:56:46 +00:00
Renderiza <tt>views/index.erb</tt> embebido en <tt>views/post.erb</tt> (por
defecto, la plantilla :index es embebida en <tt>views/layout.erb</tt> siempre y
cuando este último archivo exista).
2010-09-21 06:45:05 +00:00
2011-05-23 22:56:46 +00:00
Cualquier opción que Sinatra no entienda le será pasada al motor de renderizado
de la plantilla:
2010-09-21 06:45:05 +00:00
get '/' do
2011-05-23 22:56:46 +00:00
haml :index, :format => :html5
2010-09-21 06:45:05 +00:00
end
2011-05-23 22:56:46 +00:00
Además podés definir las opciones para un lenguaje de plantillas de forma
general:
2011-01-12 21:58:57 +00:00
2011-05-23 22:56:46 +00:00
set :haml, :format => :html5
2011-01-12 21:58:57 +00:00
get '/' do
2011-05-23 22:56:46 +00:00
haml :index
2011-01-12 21:58:57 +00:00
end
2011-05-23 22:56:46 +00:00
Las opciones pasadas al método de renderizado tienen precedencia sobre las
definidas mediante +set+.
2010-09-21 06:45:05 +00:00
2011-05-23 22:56:46 +00:00
Opciones disponibles:
2010-09-21 06:45:05 +00:00
2011-05-23 22:56:46 +00:00
[locals]
Lista de variables locales pasadas al documento. Resultan muy útiles cuando
se combinan con parciales.
Ejemplo: <tt>erb "<%= foo %>", :locals => {:foo => "bar"}</tt>
2010-09-21 06:45:05 +00:00
2011-05-23 22:56:46 +00:00
[default_encoding]
Encoding utilizado cuando el de un string es dudoso. Por defecto toma el
valor de <tt>settings.default_encoding</tt>.
2010-09-21 06:45:05 +00:00
2011-05-23 22:56:46 +00:00
[views]
Directorio desde donde se cargan las vistas. Por defecto toma el valor de
<tt>settings.views</tt>.
2010-09-21 06:45:05 +00:00
2011-05-23 22:56:46 +00:00
[layout]
Si es +true+ o +false+ indica que se debe usar, o nó, un layout,
respectivamente. También puede ser un símbolo que especifique qué plantilla
usar. Ejemplo: <tt>erb :index, :layout => !request.xhr?</tt>
2010-09-21 06:45:05 +00:00
2011-05-23 22:56:46 +00:00
[content_type]
Content-Type que produce la plantilla. El valor por defecto depende de cada
lenguaje de plantillas.
2010-10-10 11:53:43 +00:00
2011-05-23 22:56:46 +00:00
[scope]
Ámbito en el que se renderiza la plantilla. Por defecto utiliza la instancia
de la aplicación. Tené en cuenta que si cambiás esta opción las variables de
instancia y los helpers van a dejar de estar disponibles.
2010-10-10 11:53:43 +00:00
2011-05-23 22:56:46 +00:00
[layout_engine]
Motor de renderizado de plantillas que usa para el layout. Resulta
conveniente para lenguajes que no soportan layouts. Por defecto toma el valor
del motor usado para renderizar la plantilla.
Ejemplo: <tt>set :rdoc, :layout_engine => :erb</tt>
2010-10-10 11:53:43 +00:00
2011-05-23 22:56:46 +00:00
Se asume que las plantillas están ubicadas directamente bajo el directorio
<tt>./views</tt>. Para usar un directorio de vistas diferente:
2010-10-10 11:53:43 +00:00
2011-05-23 22:56:46 +00:00
set :views, settings.root + '/plantillas'
2010-09-21 06:45:05 +00:00
2011-05-23 22:56:46 +00:00
Es importante acordarse que siempre tenés que referenciar a las plantillas con
símbolos, incluso cuando se encuentran en un subdirectorio (en este caso tenés
que usar <tt>:'subdir/plantilla'</tt>). Tenés que usar un símbolo porque los
métodos de renderización van a renderizar directamente cualquier string que se
les pase como argumento.
2010-09-21 06:45:05 +00:00
2011-05-23 22:56:46 +00:00
=== Lenguajes de Plantillas Disponibles
2010-09-21 06:45:05 +00:00
2011-05-23 22:56:46 +00:00
Algunos lenguajes tienen varias implementaciones. Para especificar que
implementación usar (y para ser thread-safe), deberías requerirla antes de
usarla:
2010-09-21 06:45:05 +00:00
2011-05-23 22:56:46 +00:00
require 'rdiscount' # o require 'bluecloth'
get('/') { markdown :index }
2010-09-21 06:45:05 +00:00
2011-05-23 22:56:46 +00:00
=== Plantillas Haml
2010-09-21 06:45:05 +00:00
2011-05-23 22:56:46 +00:00
Dependencias:: {haml}[http://haml-lang.com/]
Extensiones de Archivo:: <tt>.haml</tt>
Ejemplo:: <tt>haml :index, :format => :html5</tt>
2010-09-21 06:45:05 +00:00
2011-05-23 22:56:46 +00:00
=== Plantillas Erb
2010-09-21 06:45:05 +00:00
2011-05-23 22:56:46 +00:00
Dependencias:: {erubis}[http://www.kuwata-lab.com/erubis/] o
erb (incluida en Ruby)
Extensiones de Archivo:: <tt>.erb</tt>, <tt>.rhtml</tt> o <tt>.erubis</tt>
(solamente con Erubis)
Ejemplo:: <tt>erb :index</tt>
2010-09-30 19:12:21 +00:00
2011-05-23 22:56:46 +00:00
=== Plantillas Builder
2010-09-30 19:12:21 +00:00
2011-05-23 22:56:46 +00:00
Dependencias:: {builder}[http://builder.rubyforge.org/]
Extensiones de Archivo:: <tt>.builder</tt>
Ejemplo:: <tt>builder { |xml| xml.em "hola" }</tt>
2010-09-30 19:12:21 +00:00
2011-05-23 22:56:46 +00:00
Además, acepta un bloque con la definición de la plantilla (ver el ejemplo).
2010-09-30 19:12:21 +00:00
2011-05-23 22:56:46 +00:00
=== Plantillas Nokogiri
2010-09-30 19:12:21 +00:00
2011-05-23 22:56:46 +00:00
Dependencias:: {nokogiri}[http://nokogiri.org/]
Extensiones de Archivo:: <tt>.nokogiri</tt>
Ejemplo:: <tt>nokogiri { |xml| xml.em "hola" }</tt>
2010-09-30 19:12:21 +00:00
2011-05-23 22:56:46 +00:00
Además, acepta un bloque con la definición de la plantilla (ver el ejemplo).
2010-09-30 19:12:21 +00:00
2011-05-23 22:56:46 +00:00
=== Plantillas Sass
2010-09-30 19:12:21 +00:00
2011-05-23 22:56:46 +00:00
Dependencias:: {sass}[http://sass-lang.com/]
Extensiones de Archivo:: <tt>.sass</tt>
Ejemplo:: <tt>sass :stylesheet, :style => :expanded</tt>
2010-09-21 06:45:05 +00:00
2011-05-23 22:56:46 +00:00
=== Plantillas SCSS
2010-09-21 06:45:05 +00:00
2011-05-23 22:56:46 +00:00
Dependencias:: {scss}[http://sass-lang.com/]
Extensiones de Archivo:: <tt>.scss</tt>
Ejemplo:: <tt>scss :stylesheet, :style => :expanded</tt>
2010-09-21 06:45:05 +00:00
2011-05-23 22:56:46 +00:00
=== Plantillas Less
2010-09-21 06:45:05 +00:00
2011-05-23 22:56:46 +00:00
Dependencias:: {less}[http://www.lesscss.org/]
Extensiones de Archivo:: <tt>.less</tt>
Ejemplo:: <tt>less :stylesheet</tt>
2010-09-21 06:45:05 +00:00
2010-09-30 19:12:21 +00:00
=== Plantillas Liquid
2011-05-23 22:56:46 +00:00
Dependencias:: {liquid}[http://www.liquidmarkup.org/]
Extensiones de Archivo:: <tt>.liquid</tt>
Ejemplo:: <tt>liquid :index, :locals => { :clave => 'valor' }</tt>
2010-09-30 19:12:21 +00:00
2011-05-23 22:56:46 +00:00
Como no vas a poder llamar a métodos de Ruby (excepto por +yield+) desde una
plantilla Liquid, casi siempre vas a querer pasarle locales.
2010-09-30 19:12:21 +00:00
=== Plantillas Markdown
2011-05-23 22:56:46 +00:00
Dependencias:: {rdiscount}[https://github.com/rtomayko/rdiscount],
{redcarpet}[https://github.com/tanoku/redcarpet],
{bluecloth}[http://deveiate.org/projects/BlueCloth],
{kramdown}[http://kramdown.rubyforge.org/] *o*
{maruku}[http://maruku.rubyforge.org/]
Extensiones de Archivo:: <tt>.markdown</tt>, <tt>.mkd</tt> y <tt>.md</tt>
Ejemplo:: <tt>markdown :index, :layout_engine => :erb</tt>
2010-09-30 19:12:21 +00:00
No es posible llamar métodos desde markdown, ni pasarle locales. Por lo tanto,
generalmente vas a usarlo en combinación con otro motor de renderizado:
erb :resumen, :locals => { :texto => markdown(:introduccion) }
2011-01-12 22:04:43 +00:00
Tené en cuenta que también podés llamar al método +markdown+ desde otras
2010-09-30 19:12:21 +00:00
plantillas:
%h1 Hola Desde Haml!
%p= markdown(:saludos)
2011-01-12 22:50:48 +00:00
Como no podés utilizar Ruby desde Markdown, no podés usar layouts escritos en
Markdown. De todos modos, es posible usar un motor de renderizado para el
2011-05-23 22:56:46 +00:00
layout distinto al de la plantilla pasando la opción <tt>:layout_engine</tt>.
2011-01-12 22:04:43 +00:00
2011-01-12 23:06:13 +00:00
=== Plantillas Textile
2010-09-30 19:12:21 +00:00
2011-05-23 22:56:46 +00:00
Dependencias:: {RedCloth}[http://redcloth.org/]
Extensiones de Archivo:: <tt>.textile</tt>
Ejemplo:: <tt>textile :index, :layout_engine => :erb</tt>
2010-09-30 19:12:21 +00:00
No es posible llamar métodos desde textile, ni pasarle locales. Por lo tanto,
generalmente vas a usarlo en combinación con otro motor de renderizado:
erb :resumen, :locals => { :texto => textile(:introduccion) }
2011-01-12 22:13:48 +00:00
Tené en cuenta que también podés llamar al método +textile+ desde otras
2010-09-30 19:12:21 +00:00
plantillas:
%h1 Hola Desde Haml!
%p= textile(:saludos)
2011-01-12 22:50:48 +00:00
Como no podés utilizar Ruby desde Textile, no podés usar layouts escritos en
Textile. De todos modos, es posible usar un motor de renderizado para el
2011-05-23 22:56:46 +00:00
layout distinto al de la plantilla pasando la opción <tt>:layout_engine</tt>.
2011-01-12 22:50:48 +00:00
2010-09-30 19:12:21 +00:00
=== Plantillas RDoc
2011-05-23 22:56:46 +00:00
Dependencias:: {rdoc}[http://rdoc.rubyforge.org/]
Extensiones de Archivo:: <tt>.rdoc</tt>
2011-07-31 22:33:28 +00:00
Ejemplo:: <tt>rdoc :LEEME, :layout_engine => :erb</tt>
2010-09-30 19:12:21 +00:00
No es posible llamar métodos desde rdoc, ni pasarle locales. Por lo tanto,
generalmente vas a usarlo en combinación con otro motor de renderizado:
erb :resumen, :locals => { :texto => rdoc(:introduccion) }
2011-01-12 22:13:48 +00:00
Tené en cuenta que también podés llamar al método +rdoc+ desde otras
2010-09-30 19:12:21 +00:00
plantillas:
%h1 Hola Desde Haml!
%p= rdoc(:saludos)
2011-01-12 22:50:48 +00:00
Como no podés utilizar Ruby desde RDoc, no podés usar layouts escritos en RDoc.
De todos modos, es posible usar un motor de renderizado para el layout distinto
2011-05-23 22:56:46 +00:00
al de la plantilla pasando la opción <tt>:layout_engine</tt>.
2011-01-12 22:50:48 +00:00
2010-09-30 19:12:21 +00:00
=== Plantillas Radius
2011-05-23 22:56:46 +00:00
Dependencias:: {radius}[http://radius.rubyforge.org/]
Extensiones de Archivo:: <tt>.radius</tt>
Ejemplo:: <tt>radius :index, :locals => { :clave => 'valor' }</tt>
2010-09-30 19:12:21 +00:00
2011-05-23 22:56:46 +00:00
Como no vas a poder llamar a métodos de Ruby (excepto por +yield+) desde una
plantilla Radius, casi siempre vas a querer pasarle locales.
2010-09-30 19:12:21 +00:00
=== Plantillas Markaby
2011-05-23 22:56:46 +00:00
Dependencias:: {markaby}[http://markaby.github.com/]
Extensiones de Archivo:: <tt>.mab</tt>
Ejemplos:: <tt>markaby { h1 "Bienvenido!" }</tt>
2010-12-20 16:04:20 +00:00
2011-05-23 22:56:46 +00:00
Además, acepta un bloque con la definición de la plantilla (ver el ejemplo).
2010-12-20 16:04:20 +00:00
2010-11-05 12:59:49 +00:00
=== Plantillas Slim
2011-05-23 22:56:46 +00:00
Dependencias:: {slim}[http://slim-lang.com/]
Extensiones de Archivo:: <tt>.slim</tt>
Ejemplo:: <tt>slim :index</tt>
2010-11-05 12:59:49 +00:00
2011-04-15 09:51:35 +00:00
=== Plantillas Creole
2011-05-23 22:56:46 +00:00
Dependencias:: {creole}[https://github.com/minad/creole]
Extensiones de Archivo:: <tt>.creole</tt>
Ejemplo:: <tt>creole :wiki, :layout_engine => :erb</tt>
2011-04-15 09:51:35 +00:00
2011-05-23 22:56:46 +00:00
No es posible llamar métodos desde creole, ni pasarle locales. Por lo tanto,
generalmente vas a usarlo en combinación con otro motor de renderizado:
2010-09-30 19:12:21 +00:00
2011-05-23 22:56:46 +00:00
erb :resumen, :locals => { :texto => cerole(:introduccion) }
2011-01-12 22:24:20 +00:00
2011-05-23 22:56:46 +00:00
Tené en cuenta que también podés llamar al método +creole+ desde otras
plantillas:
2011-01-12 22:24:20 +00:00
2011-05-23 22:56:46 +00:00
%h1 Hola Desde Haml!
%p= creole(:saludos)
2010-09-30 19:12:21 +00:00
2011-05-23 22:56:46 +00:00
Como no podés utilizar Ruby desde Creole, no podés usar layouts escritos en
Creloe. De todos modos, es posible usar un motor de renderizado para el layout
distinto al de la plantilla pasando la opción <tt>:layout_engine</tt>.
2010-09-30 19:12:21 +00:00
2011-05-23 22:56:46 +00:00
=== Plantillas CoffeeScript
2010-09-30 19:12:21 +00:00
2011-05-23 22:56:46 +00:00
Dependencias:: {coffee-script}[https://github.com/josh/ruby-coffee-script]
y un {mecanismo para ejecutar javascript}[https://github.com/sstephenson/execjs/blob/master/README.md#readme]
Extensiones de Archivo:: <tt>.coffee</tt>
Ejemplo:: <tt>coffee :index</tt>
2010-09-30 19:12:21 +00:00
2011-01-12 22:52:53 +00:00
=== Plantillas Embebidas
2010-09-21 06:45:05 +00:00
get '/' do
haml '%div.titulo Hola Mundo'
end
2011-01-12 22:52:53 +00:00
Renderiza el template embebido en el string.
2010-09-21 06:45:05 +00:00
=== Accediendo a Variables en Plantillas
Las plantillas son evaluadas dentro del mismo contexto que los manejadores de
2010-09-21 02:13:40 +00:00
ruta. Las variables de instancia asignadas en los manejadores de ruta son
accesibles directamente por las plantillas:
2010-09-21 06:45:05 +00:00
get '/:id' do
@foo = Foo.find(params[:id])
haml '%h1= @foo.nombre'
end
2010-09-21 02:13:40 +00:00
O es posible especificar un Hash de variables locales explícitamente:
2010-09-21 06:45:05 +00:00
get '/:id' do
foo = Foo.find(params[:id])
2011-05-23 23:00:47 +00:00
haml '%h1= bar.nombre', :locals => { :bar => foo }
2010-09-21 06:45:05 +00:00
end
Esto es usado típicamente cuando se renderizan plantillas como parciales desde
adentro de otras plantillas.
=== Plantillas Inline
Las plantillas pueden ser definidas al final del archivo fuente:
require 'rubygems'
require 'sinatra'
get '/' do
haml :index
end
__END__
@@ layout
%html
= yield
@@ index
%div.titulo Hola mundo!!!!!
NOTA: únicamente las plantillas inline definidas en el archivo fuente que
2010-10-12 15:16:29 +00:00
requiere sinatra son cargadas automáticamente. Llamá <tt>enable
:inline_templates</tt> explícitamente si tenés plantillas inline en otros
2010-09-21 06:45:05 +00:00
archivos fuente.
=== Plantillas Nombradas
Las plantillas también pueden ser definidas usando el método top-level
<tt>template</tt>:
template :layout do
"%html\n =yield\n"
end
template :index do
'%div.titulo Hola Mundo!'
end
get '/' do
haml :index
end
Si existe una plantilla con el nombre "layout", va a ser usada cada vez que
2011-01-10 15:21:05 +00:00
una plantilla es renderizada. Podés desactivar los layouts individualmente
pasando <tt>:layout => false</tt> o globalmente con
2011-03-09 00:12:32 +00:00
<tt>set :haml, :layout => false</tt>:
2010-09-21 06:45:05 +00:00
get '/' do
haml :index, :layout => !request.xhr?
end
2011-01-12 22:56:15 +00:00
=== Asociando Extensiones de Archivo
Para asociar una extensión de archivo con un motor de renderizado, usá
<tt>Tilt.register</tt>. Por ejemplo, si querés usar la extensión +tt+ para
2011-01-13 08:33:26 +00:00
las plantillas Textile, podés hacer lo siguiente:
2011-01-12 22:56:15 +00:00
Tilt.register :tt, Tilt[:textile]
2011-01-12 23:00:07 +00:00
=== Agregando Tu Propio Motor de Renderizado
Primero, registrá tu motor con Tilt, y después, creá tu método de renderizado:
Tilt.register :mipg, MiMotorParaPlantillaGenial
helpers do
def mypg(*args) render(:mypg, *args) end
end
get '/' do
mypg :index
end
Renderiza <tt>./views/index.mypg</tt>. Mirá https://github.com/rtomayko/tilt
para aprender más de Tilt.
2010-09-21 02:13:40 +00:00
== Filtros
2010-09-21 06:45:05 +00:00
2011-02-21 21:06:42 +00:00
Los filtros +before+ son evaluados antes de cada petición dentro del mismo
contexto que las rutas. Pueden modificar la petición y la respuesta. Las
variables de instancia asignadas en los filtros son accesibles por las rutas y
las plantillas:
2010-09-21 06:45:05 +00:00
before do
@nota = 'Hey!'
request.path_info = '/foo/bar/baz'
end
get '/foo/*' do
@nota #=> 'Hey!'
params[:splat] #=> 'bar/baz'
end
2011-02-21 21:06:42 +00:00
Los filtros +after+ son evaluados después de cada petición dentro del mismo
contexto y también pueden modificar la petición y la respuesta. Las variables
de instancia asignadas en los filtros +before+ y en las rutas son accesibles por
los filtros +after+:
2010-09-21 06:45:05 +00:00
after do
puts response.status
end
2011-02-21 21:06:42 +00:00
Nota: A menos que usés el método +body+ en lugar de simplemente devolver un
2011-02-18 20:19:38 +00:00
string desde una ruta, el cuerpo de la respuesta no va a estar disponible en
un filtro after, debido a que todavía no se ha generado.
2010-09-21 06:45:05 +00:00
Los filtros aceptan un patrón opcional, que cuando está presente causa que los
mismos sean evaluados únicamente si el path de la petición coincide con ese
patrón:
before '/protegido/*' do
autenticar!
end
after '/crear/:slug' do |slug|
session[:ultimo_slug] = slug
end
2011-02-21 21:06:42 +00:00
Al igual que las rutas, los filtros también pueden aceptar condiciones:
2010-12-20 16:04:20 +00:00
before :agent => /Songbird/ do
# ...
end
after '/blog/*', :host_name => 'ejemplo.com' do
# ...
end
2011-02-18 20:23:27 +00:00
== Ayudantes
Usá el método top-level <tt>helpers</tt> para definir métodos ayudantes que
pueden ser utilizados dentro de los manejadores de rutas y las plantillas:
helpers do
def bar(nombre)
"#{nombre}bar"
end
end
get '/:nombre' do
bar(params[:nombre])
end
2011-02-21 21:06:42 +00:00
=== Usando Sesiones
Una sesión es usada para mantener el estado a través de distintas peticiones.
Cuando están activadas, tenés un hash de sesión para cada sesión de usuario:
enable :sessions
get '/' do
"valor = " << session[:valor].inspect
end
get '/:valor' do
session[:valor] = params[:valor]
end
Tené en cuenta que <tt>enable :sessions</tt> guarda todos los datos en una
cookie, lo que no es siempre deseable (guardar muchos datos va a incrementar
tu tráfico, por citar un ejemplo). Podés usar cualquier middleware Rack para
manejar sesiones, de la misma manera que usarías cualquier otro middleware,
pero con la salvedad de que *no* tenés que llamar a <tt>enable :sessions</tt>:
use Rack::Session::Pool, :expire_after => 2592000
get '/' do
"valor = " << session[:valor].inspect
end
get '/:valor' do
session[:valor] = params[:valor]
end
2011-03-13 19:39:02 +00:00
Para incrementar la seguridad, los datos de la sesión almacenados en
la cookie son firmados con un secreto de sesión. Este secreto, es
generado aleatoriamente por Sinatra. De cualquier manera, hay que
tener en cuenta que cada vez que inicies la aplicación se va a generar
uno nuevo. Así, si querés que todas las instancias de tu aplicación
compartan un único secreto, tenés que definirlo vos:
set :session_secret, 'super secreto'
2011-03-20 18:05:43 +00:00
Si necesitás una configuración más específica, +sessions+ acepta un
Hash con opciones:
set :sessions, :domain => 'foo.com'
2011-02-18 20:23:27 +00:00
=== Interrupción
2010-09-21 06:45:05 +00:00
Para detener inmediatamente una petición dentro de un filtro o una ruta usá:
halt
2010-09-30 19:12:21 +00:00
También podés especificar el estado:
2010-09-21 06:45:05 +00:00
halt 410
2010-09-30 19:12:21 +00:00
O el cuerpo:
2010-09-21 06:45:05 +00:00
halt 'esto va a ser el cuerpo'
2010-09-30 19:12:21 +00:00
O los dos:
2010-09-21 06:45:05 +00:00
halt 401, 'salí de acá!'
2010-09-30 19:12:21 +00:00
Con cabeceras:
2010-09-21 06:45:05 +00:00
halt 402, { 'Content-Type' => 'text/plain' }, 'venganza'
2011-03-01 15:05:24 +00:00
Obviamente, es posible utilizar +halt+ con una plantilla:
halt erb(:error)
2011-02-18 20:23:27 +00:00
=== Paso
2010-09-21 06:45:05 +00:00
Una ruta puede pasarle el procesamiento a la siguiente ruta que coincida con
la petición usando <tt>pass</tt>:
get '/adivina/:quien' do
pass unless params[:quien] == 'Franco'
'Adivinaste!'
end
get '/adivina/*' do
'Erraste!'
end
Se sale inmediatamente del bloque de la ruta y se le pasa el control a la
siguiente ruta que coincida. Si no coincide ninguna ruta, se devuelve un 404.
2011-02-21 21:06:42 +00:00
=== Ejecutando Otra Ruta
Cuando querés obtener el resultado de la llamada a una ruta, +pass+ no te va a
servir. Para lograr esto, podés usar +call+:
get '/foo' do
2011-04-17 10:43:22 +00:00
status, headers, body = call env.merge("PATH_INFO" => '/bar')
2011-04-17 10:56:03 +00:00
[status, headers, body.map(&:upcase)]
2011-02-21 21:06:42 +00:00
end
get '/bar' do
"bar"
end
Notá que en el ejemplo anterior, es conveniente mover <tt>"bar"</tt> a un
helper, y llamarlo desde <tt>/foo</tt> y <tt>/bar</tt>. Así, vas a simplificar
las pruebas y a mejorar el rendimiento.
Si querés que la petición se envíe a la misma instancia de la aplicación en
lugar de a otra, usá <tt>call!</tt> en lugar de <tt>call</tt>.
En la especificación de Rack podés encontrar más información sobre
<tt>call</tt>.
=== Asignando el Código de Estado, los Encabezados y el Cuerpo de una Respuesta
2011-02-18 20:56:22 +00:00
Es posible, y se recomienda, asignar el código de estado y el cuerpo de una
respuesta con el valor de retorno de una ruta. De cualquier manera, en varios
escenarios, puede que sea conveniente asignar el cuerpo en un punto arbitrario
2011-02-21 21:06:42 +00:00
del flujo de ejecución con el método +body+. A partir de ahí, podés usar ese
2011-02-18 20:56:22 +00:00
mismo método para acceder al cuerpo de la respuesta:
get '/foo' do
body "bar"
end
after do
puts body
end
2011-02-21 21:06:42 +00:00
También es posible pasarle un bloque a +body+, que será ejecutado por el Rack
handler (podés usar esto para implementar streaming, mirá "Valores de retorno").
2011-02-18 20:56:22 +00:00
2011-02-21 21:06:42 +00:00
De manera similar, también podés asignar el código de estado y encabezados:
2011-02-18 20:56:22 +00:00
get '/foo' do
status 418
2011-02-21 21:06:42 +00:00
headers \
2011-08-09 10:26:53 +00:00
"Allow" => "BREW, POST, GET, PROPFIND, WHEN",
2011-02-21 21:06:42 +00:00
"Refresh" => "Refresh: 20; http://www.ietf.org/rfc/rfc2324.txt"
body "I'm a tea pot!"
end
También, al igual que +body+, tanto +status+ como +headers+ pueden utilizarse
para obtener sus valores cuando no se les pasa argumentos.
2011-08-22 19:41:07 +00:00
=== Streaming De Respuestas
A veces vas a querer empezar a enviar la respuesta a pesar de que todavía no
terminaste de generar su cuerpo. También es posible que, en algunos casos,
quieras seguir enviando información hasta que el cliente cierre la conexión.
Cuando esto ocurra, el +stream+ helper te va a ser de gran ayuda:
get '/' do
stream do |out|
out << "Esto va a ser legen -\n"
sleep 0.5
out << " (esperalo) \n"
sleep 1
out << "- dario!\n"
end
end
Podés implementar APIs de streaming,
{Server-Sent Events}[http://dev.w3.org/html5/eventsource/] y puede ser usado
como base para {WebSockets}[http://es.wikipedia.org/wiki/WebSockets]. También
puede ser usado para incrementar el throughput si solo una parte del contenido
depende de un recurso lento.
Hay que tener en cuenta que el comportamiento del streaming, especialmente el
número de peticiones concurrentes, depende del servidor web utilizado para
servir la aplicación. Puede que algunos servidores, como es el caso de
WEBRick, no soporten streaming directamente, así el cuerpo de la respuesta será
enviado completamente de una vez cuando el bloque pasado a +stream+ finalice su
2011-10-28 18:31:27 +00:00
ejecución. Si estás usando Shotgun, el streaming no va a funcionar.
2011-08-22 19:41:07 +00:00
2011-09-01 17:02:27 +00:00
Cuando se pasa +keep_open+ como parámetro, no se va a enviar el mensaje
+close+ al objeto de stream. Queda en vos cerrarlo en el punto de ejecución
que quieras. Nuevamente, hay que tener en cuenta que este comportamiento es
posible solo en servidores que soporten eventos, como Thin o Rainbows. El
2011-09-03 02:18:45 +00:00
resto de los servidores van a cerrar el stream de todos modos:
2011-08-22 19:41:07 +00:00
set :server, :thin
conexiones = []
get '/' do
# mantenemos abierto el stream
2011-09-01 17:02:27 +00:00
stream(:keep_open) { |salida| conexiones << salida }
2011-08-22 19:41:07 +00:00
end
post '/' do
# escribimos a todos los streams abiertos
conexiones.each { |salida| salida << params[:mensaje] << "\n" }
"mensaje enviado"
end
2011-03-21 16:55:41 +00:00
=== Log (Registro)
En el ámbito de la petición, el helper +logger+ (registrador) expone
una instancia de +Logger+:
get '/' do
logger.info "cargando datos"
# ...
end
Este logger tiene en cuenta la configuración de logueo de tu Rack
handler. Si el logueo está desactivado, este método va a devolver un
objeto que se comporta como un logger pero que en realidad no hace
nada. Así, no vas a tener que preocuparte por esta situación.
Tené en cuenta que el logueo está habilitado por defecto únicamente
para <tt>Sinatra::Application</tt>. Si heredaste de
<tt>Sinatra::Base</tt>, probablemente quieras habilitarlo manualmente:
class MiApp < Sinatra::Base
2011-10-23 15:18:22 +00:00
configure :production, :development do
2011-03-21 16:55:41 +00:00
enable :logging
end
end
2011-10-23 15:30:08 +00:00
Para evitar que se inicialice cualquier middleware de logging, configurá
+logging+ a +nil+. Tené en cuenta que, cuando hagas esto, +logger+ va a
devolver +nil+. Un caso común es cuando querés usar tu propio logger. Sinatra
va a usar lo que encuentre en <tt>env['rack.logger']</tt>.
2011-02-21 21:06:42 +00:00
=== Tipos Mime
Cuando usás <tt>send_file</tt> o archivos estáticos tal vez tengas tipos mime
que Sinatra no entiende. Usá +mime_type+ para registrarlos a través de la
extensión de archivo:
2011-05-24 22:02:02 +00:00
configure do
mime_type :foo, 'text/foo'
end
2011-02-21 21:06:42 +00:00
También lo podés usar con el ayudante +content_type+:
get '/' do
content_type :foo
"foo foo foo"
2011-02-18 20:56:22 +00:00
end
2011-02-21 21:06:42 +00:00
=== Generando URLs
Para generar URLs deberías usar el método +url+. Por ejemplo, en Haml:
%a{:href => url('/foo')} foo
Tiene en cuenta proxies inversos y encaminadores de Rack, si están presentes.
Este método también puede invocarse mediante su alias +to+ (mirá un ejemplo
a continuación).
2011-02-18 21:05:55 +00:00
=== Redirección del Navegador
2011-02-21 21:06:42 +00:00
Podés redireccionar al navegador con el método +redirect+:
2011-02-18 21:05:55 +00:00
get '/foo' do
2011-02-21 21:06:42 +00:00
redirect to('/bar')
2011-02-18 21:05:55 +00:00
end
Cualquier parámetro adicional se utiliza de la misma manera que los argumentos
2011-02-21 21:06:42 +00:00
pasados a +halt+:
redirect to('/bar'), 303
redirect 'http://google.com', 'te confundiste de lugar, compañero'
2011-02-18 21:05:55 +00:00
2011-02-21 21:06:42 +00:00
También podés redireccionar fácilmente de vuelta hacia la página desde donde
vino el usuario con +redirect back+:
2011-02-18 21:05:55 +00:00
2011-02-21 21:06:42 +00:00
get '/foo' do
"<a href='/bar'>hacer algo</a>"
end
get '/bar' do
hacer_algo
redirect back
end
Para pasar argumentos con una redirección, podés agregarlos a la cadena de
2011-02-18 21:05:55 +00:00
búsqueda:
2011-02-21 21:06:42 +00:00
redirect to('/bar?suma=42')
2011-02-18 21:05:55 +00:00
O usar una sesión:
2011-08-23 10:49:23 +00:00
enable :sessions
2011-02-18 21:05:55 +00:00
get '/foo' do
session[:secreto] = 'foo'
2011-02-21 21:06:42 +00:00
redirect to('/bar')
2011-02-18 21:05:55 +00:00
end
get '/bar' do
session[:secreto]
end
2011-02-21 21:06:42 +00:00
=== Cache Control
Asignar tus encabezados correctamente es el cimiento para realizar un cacheo
HTTP correcto.
Podés asignar el encabezado Cache-Control fácilmente:
get '/' do
cache_control :public
"cachealo!"
end
2011-03-09 00:12:32 +00:00
Pro tip: configurar el cacheo en un filtro +before+:
2011-02-21 21:06:42 +00:00
before do
cache_control :public, :must_revalidate, :max_age => 60
end
Si estás usando el helper +expires+ para definir el encabezado correspondiente,
<tt>Cache-Control</tt> se va a definir automáticamente:
before do
expires 500, :public, :must_revalidate
end
2011-09-03 01:57:14 +00:00
Para usar cachés adecuadamente, deberías considerar usar +etag+ o
2011-02-21 21:06:42 +00:00
+last_modified+. Es recomendable que llames a estos helpers *antes* de hacer
cualquier trabajo pesado, ya que van a enviar la respuesta inmediatamente si
2011-03-09 00:12:32 +00:00
el cliente ya tiene la versión actual en su caché:
2011-02-21 21:06:42 +00:00
get '/articulo/:id' do
@articulo = Articulo.find params[:id]
last_modified @articulo.updated_at
etag @articulo.sha1
erb :articulo
end
También es posible usar una
{weak ETag}[http://en.wikipedia.org/wiki/HTTP_ETag#Strong_and_weak_validation]:
etag @articulo.sha1, :weak
Estos helpers no van a cachear nada por vos, sino que van a facilitar la
información necesaria para poder hacerlo. Si estás buscando soluciones rápidas
2011-09-03 01:57:14 +00:00
de cacheo con proxys inversos, mirá
{rack-cache}[http://rtomayko.github.com/rack-cache/]:
2011-02-21 21:06:42 +00:00
require "rack/cache"
require "sinatra"
use Rack::Cache
get '/' do
cache_control :public, :max_age => 36000
sleep 5
"hola"
end
2011-06-12 16:09:37 +00:00
Usá la configuración <tt>:static_cache_control</tt> para agregar el encabezado
<tt>Cache-Control</tt> a archivos estáticos (ver la sección de configuración
para más detalles).
2011-09-18 19:00:29 +00:00
De acuerdo con la RFC 2616 tu aplicación debería comportarse diferente si a las
cabeceras If-Match o If-None-Match se le asigna el valor <tt>*</tt> cuando el
recurso solicitado ya existe. Sinatra asume para peticiones seguras (como get)
e idempotentes (como put) que el recurso existe, mientras que para el resto
(como post), que no. Podes cambiar este comportamiento con la opción
<tt>:new_resource</tt>:
get '/crear' do
etag '', :new_resource => true
Articulo.create
erb :nuevo_articulo
end
Si querés seguir usando una weak ETag, indicalo con la opción <tt>:kind</tt>:
etag '', :new_resource => true, :kind => :weak
2011-02-21 21:06:42 +00:00
=== Enviando Archivos
Para enviar archivos, podés usar el método <tt>send_file</tt>:
get '/' do
send_file 'foo.png'
end
Además acepta un par de opciones:
send_file 'foo.png', :type => :jpg
Estas opciones son:
[filename]
nombre del archivo respondido, por defecto es el nombre real del archivo.
[last_modified]
valor para el encabezado Last-Modified, por defecto toma el mtime del archivo.
[type]
el content type que se va a utilizar, si no está presente se intenta adivinar
a partir de la extensión del archivo.
[disposition]
se utiliza para el encabezado Content-Disposition, y puede tomar alguno de los
siguientes valores: +nil+ (por defecto), <tt>:attachment</tt> e
<tt>:inline</tt>
[length]
encabezado Content-Length, por defecto toma el tamaño del archivo.
Si el Rack handler lo soporta, se intentará no transmitir directamente desde el
proceso de Ruby. Si usás este método, Sinatra se va a encargar automáticamente
peticiones de rango.
2011-02-18 20:23:27 +00:00
=== Accediendo al objeto de la petición
2010-10-11 20:38:50 +00:00
El objeto de la petición entrante puede ser accedido desde el nivel de la
petición (filtros, rutas y manejadores de errores) a través del método
2011-02-21 21:06:42 +00:00
<tt>request</tt>:
2010-10-11 20:38:50 +00:00
# app corriendo en http://ejemplo.com/ejemplo
get '/foo' do
2011-03-28 21:44:52 +00:00
t = %w[text/css text/html application/javascript]
request.accept # ['text/html', '*/*']
request.accept? 'text/xml' # true
request.preferred_type(t) # 'text/html'
request.body # cuerpo de la petición enviado por el cliente (ver más abajo)
request.scheme # "http"
request.script_name # "/ejemplo"
request.path_info # "/foo"
request.port # 80
request.request_method # "GET"
request.query_string # ""
request.content_length # longitud de request.body
request.media_type # tipo de medio de request.body
request.host # "ejemplo.com"
request.get? # true (hay métodos análogos para los otros verbos)
request.form_data? # false
request["UNA_CABECERA"] # valor de la cabecera UNA_CABECERA
request.referrer # la referencia del cliente o '/'
request.user_agent # user agent (usado por la condición :agent)
request.cookies # hash de las cookies del browser
request.xhr? # es una petición ajax?
request.url # "http://ejemplo.com/ejemplo/foo"
request.path # "/ejemplo/foo"
request.ip # dirección IP del cliente
request.secure? # false (sería true sobre ssl)
request.forwarded? # true (si se está corriendo atrás de un proxy inverso)
requuest.env # hash de entorno directamente entregado por Rack
2010-10-11 20:38:50 +00:00
end
Algunas opciones, como <tt>script_name</tt> o <tt>path_info</tt> pueden
también ser escritas:
before { request.path_info = "/" }
get "/" do
"todas las peticiones llegan acá"
end
El objeto <tt>request.body</tt> es una instancia de IO o StringIO:
post "/api" do
request.body.rewind # en caso de que alguien ya lo haya leído
datos = JSON.parse request.body.read
"Hola #{datos['nombre']}!"
end
2011-02-21 21:06:42 +00:00
=== Archivos Adjuntos
Podés usar el método helper +attachment+ para indicarle al navegador que
2011-03-09 00:12:32 +00:00
almacene la respuesta en el disco en lugar de mostrarla en pantalla:
2011-02-21 21:06:42 +00:00
get '/' do
attachment
"guardalo!"
end
También podés pasarle un nombre de archivo:
get '/' do
attachment "info.txt"
"guardalo!"
end
2011-08-25 23:29:12 +00:00
=== Fecha y Hora
Sinatra pone a tu disposición el helper +time_for+, que genera un objeto +Time+
a partir del valor que recibe como argumento. Este valor puede ser un
+String+, pero también es capaz de convertir objetos +DateTime+, +Date+ y de
2011-09-03 02:18:45 +00:00
otras clases similares:
2011-08-25 23:29:12 +00:00
get '/' do
pass if Time.now > time_for('Dec 23, 2012')
"todavía hay tiempo"
end
Este método es usado internamente por métodos como +expires+ y +last_modified+,
entre otros. Por lo tanto, es posible extender el comportamiento de estos
métodos sobreescribiendo +time_for+ en tu aplicación:
helpers do
def time_for(value)
case value
when :ayer then Time.now - 24*60*60
when :mañana then Time.now + 24*60*60
else super
end
end
end
get '/' do
last_modified :ayer
expires :mañana
"hola"
end
2011-02-21 21:06:42 +00:00
=== Buscando los Archivos de las Plantillas
El helper <tt>find_template</tt> se utiliza para encontrar los archivos de las
plantillas que se van a renderizar:
find_template settings.views, 'foo', Tilt[:haml] do |archivo|
puts "podría ser #{archivo}"
end
Si bien esto no es muy útil, lo interesante es que podés sobreescribir este
método, y así enganchar tu propio mecanismo de búsqueda. Por ejemplo, para
poder utilizar más de un directorio de vistas:
set :views, ['vistas', 'plantillas']
helpers do
def find_template(views, name, engine, &block)
Array(views).each { |v| super(v, name, engine, &block) }
end
end
Otro ejemplo consiste en usar directorios diferentes para los distintos motores
de renderizado:
set :views, :sass => 'vistas/sass', :haml => 'plantillas', :defecto => 'vistas'
helpers do
def find_template(views, name, engine, &block)
_, folder = views.detect { |k,v| engine == Tilt[k] }
folder ||= views[:defecto]
super(folder, name, engine, &block)
end
end
¡Es muy fácil convertir estos ejemplos en una extensión y compartirla!.
Notá que <tt>find_template</tt> no verifica si un archivo existe realmente, sino
que llama al bloque que recibe para cada path posible. Esto no representa un
problema de rendimiento debido a que +render+ va a usar +break+ ni bien
encuentre un archivo que exista. Además, las ubicaciones de las plantillas (y
su contenido) se cachean cuando no estás en el modo de desarrollo. Es bueno
tener en cuenta lo anteiror si escribís un método medio loco.
2010-09-21 06:45:05 +00:00
== Configuración
Ejecutar una vez, en el inicio, en cualquier entorno:
configure do
2011-02-21 21:06:42 +00:00
# asignando una opción
set :opcion, 'valor'
# asignando varias opciones
set :a => 1, :b => 2
# atajo para `set :opcion, true`
enable :opcion
# atajo para `set :opcion, false`
disable :opcion
# también podés tener configuraciones dinámicas usando bloques
set(:css_dir) { File.join(views, 'css') }
2010-09-21 06:45:05 +00:00
end
Ejecutar únicamente cuando el entorno (la variable de entorno RACK_ENV) es
<tt>:production</tt>:
configure :production do
...
end
Ejecutar cuando el entorno es <tt>:production</tt> o <tt>:test</tt>:
configure :production, :test do
...
end
2011-02-21 21:06:42 +00:00
Podés acceder a estas opciones utilizando el método <tt>settings</tt>:
configure do
set :foo, 'bar'
end
get '/' do
settings.foo? # => true
settings.foo # => 'bar'
...
end
2011-10-23 15:16:13 +00:00
=== Configurando la Protección de Ataques
2011-09-05 00:47:01 +00:00
Sinatra usa {Rack::Protection}[https://github.com/rkh/rack-protection#readme]
para defender a tu aplicación de los ataques más comunes. Tenés que tener en
cuenta que como consecuencia de esto puede venir asociada una disminución del
rendimiento de tu aplicación. Si por este, o algún otro motivo, querés
desactivar está funcionalidad, podés hacerlo:
disable :protection
También es posible desactivar una única capa de defensa:
set :protection, :except => :path_traversal
O varias:
set :protections, :except => [:path_traversal, :session_hijacking]
2011-02-21 21:06:42 +00:00
=== Configuraciones Disponibles
2011-06-12 16:09:37 +00:00
[absolute_redirects] si está deshabilitada, Sinatra va a permitir
redirecciones relativas, sin embargo, como consecuencia
de esto, va a dejar de cumplir con el RFC 2616 (HTTP
1.1), que solamente permite redirecciones absolutas.
Activalo si tu apliación está corriendo atrás de un proxy
inverso que no se ha configurado adecuadamente. Notá que
el helper +url+ va a seguir produciendo URLs absolutas, a
menos que le pasés +false+ como segundo parámetro.
2011-02-21 21:06:42 +00:00
2011-06-12 16:09:37 +00:00
Deshabilitada por defecto.
2011-02-21 21:06:42 +00:00
2011-06-12 16:09:37 +00:00
[add_charsets] tipos mime a los que el helper <tt>content_type</tt> les
añade automáticamente el charset.
2011-02-21 21:06:42 +00:00
2011-06-12 16:09:37 +00:00
En general, no deberías asignar directamente esta opción,
sino añadirle los charsets que quieras:
2011-02-21 21:06:42 +00:00
2011-06-12 16:09:37 +00:00
settings.add_charsets << "application/foobar"
2011-02-21 21:06:42 +00:00
2011-06-12 16:09:37 +00:00
[app_file] archivo principal de la aplicación, se utiliza para
detectar la raíz del proyecto, el directorio de las
vistas y el público así como las plantillas inline.
2011-02-21 21:06:42 +00:00
2011-06-12 16:09:37 +00:00
[bind] dirección IP que utilizará el servidor integrado (por
defecto: 0.0.0.0).
2011-02-21 21:06:42 +00:00
2011-06-12 16:09:37 +00:00
[default_encoding] encoding utilizado cuando el mismo se desconoce (por
defecto <tt>"utf-8"</tt>).
2011-02-21 21:06:42 +00:00
2011-06-12 16:09:37 +00:00
[dump_errors] mostrar errores en el log.
2011-02-21 21:06:42 +00:00
2011-06-12 16:09:37 +00:00
[environment] entorno actual, por defecto toma el valor de
<tt>ENV['RACK_ENV']</tt>, o <tt>"development"</tt> si no
está disponible.
2011-02-21 21:06:42 +00:00
2011-06-12 16:09:37 +00:00
[logging] define si se utiliza el logger.
2011-02-21 21:06:42 +00:00
2011-06-12 16:09:37 +00:00
[lock] coloca un lock alrededor de cada petición, procesando
solamente una por proceso.
2011-02-21 21:06:42 +00:00
2011-06-12 16:09:37 +00:00
Habilitá esta opción si tu aplicación no es thread-safe.
Se encuentra deshabilitada por defecto.
2011-02-21 21:06:42 +00:00
2011-06-12 16:09:37 +00:00
[method_override] utiliza el parámetro <tt>_method</tt> para permtir
formularios put/delete en navegadores que no los
soportan.
2011-02-21 21:06:42 +00:00
2011-06-12 16:09:37 +00:00
[port] puerto en el que escuchará el servidor integrado.
2011-02-21 21:06:42 +00:00
2011-06-12 16:09:37 +00:00
[prefixed_redirects] define si inserta <tt>request.script_name</tt> en las
redirecciones cuando no se proporciona un path absoluto.
De esta manera, cuando está habilitada,
<tt>redirect '/foo'</tt> se comporta de la misma manera
que <tt>redirect to('/foo')</tt>. Se encuentra
deshabilitada por defecto.
2011-02-21 21:06:42 +00:00
2011-09-05 00:47:01 +00:00
[protection] define si deben activarse las protecciones para los
ataques web más comunes. Para más detalles mirá la
sección sobre la configuración de protección de ataques
más arriba.
2011-06-15 22:24:27 +00:00
[public_folder] directorio desde donde se sirven los archivos públicos.
2011-02-21 21:06:42 +00:00
2011-06-12 16:09:37 +00:00
[reload_templates] define si se recargan las plantillas entre peticiones.
2011-02-21 21:06:42 +00:00
2011-06-12 16:09:37 +00:00
Se encuentra activado en el entorno de desarrollo.
2011-02-21 21:06:42 +00:00
2011-06-12 16:09:37 +00:00
[root] directorio raíz del proyecto.
2011-02-21 21:06:42 +00:00
2011-06-12 16:09:37 +00:00
[raise_errors] elevar excepciones (detiene la aplicación).
2011-02-21 21:06:42 +00:00
2011-06-12 16:09:37 +00:00
[run] cuando está habilitada, Sinatra se va a encargar de
iniciar el servidor web, no la habilités cuando estés
usando rackup o algún otro medio.
2011-02-21 21:06:42 +00:00
2011-06-12 16:09:37 +00:00
[running] indica si el servidor integrado está ejecutandose, ¡no
cambiés esta configuración!.
2011-02-21 21:06:42 +00:00
2011-06-12 16:09:37 +00:00
[server] servidor, o lista de servidores, para usar como servidor
integrado. Por defecto: ['thin', 'mongrel', 'webrick'],
el orden establece la prioridad.
2011-02-21 21:06:42 +00:00
2011-06-12 16:09:37 +00:00
[sessions] habilita sesiones basadas en cookies.
2011-02-21 21:06:42 +00:00
2011-06-12 16:09:37 +00:00
[show_exceptions] muestra un stack trace en el navegador.
2011-02-21 21:06:42 +00:00
2011-06-12 16:09:37 +00:00
[static] define si Sinatra debe encargarse de servir archivos
estáticos.
2011-02-21 21:06:42 +00:00
2011-06-12 16:09:37 +00:00
Deshabilitala cuando usés un servidor capaz de
hacerlo por sí solo, porque mejorará el
rendimiento. Se encuentra habilitada por
defecto en el estilo clásico y desactivado en el
el modular.
2011-02-21 21:06:42 +00:00
2011-06-12 16:09:37 +00:00
[static_cache_control] cuando Sinatra está sirviendo archivos estáticos, y
está opción está habilitada, les va a agregar encabezados
<tt>Cache-Control</tt> a las respuestas. Para esto
utiliza el helper +cache_control+. Se encuentra
deshabilitada por defecto. Notar que es necesario
utilizar un array cuando se asignan múltiples valores:
<tt>set :static_cache_control, [:public, :max_age => 300]</tt>.
2011-02-21 21:06:42 +00:00
2011-06-12 16:09:37 +00:00
[views] directorio de las vistas.
2011-02-21 21:06:42 +00:00
2011-01-12 23:05:26 +00:00
== Manejo de Errores
2010-09-21 06:45:05 +00:00
Los manejadores de errores se ejecutan dentro del mismo contexto que las rutas
2011-02-21 21:06:42 +00:00
y los filtros +before+, lo que significa que podés usar, por ejemplo,
2010-09-21 06:45:05 +00:00
<tt>haml</tt>, <tt>erb</tt>, <tt>halt</tt>, etc.
=== No encontrado <em>(Not Found)</em>
Cuando se eleva una excepción <tt>Sinatra::NotFound</tt>, o el código de
estado de la respuesta es 404, el manejador <tt>not_found</tt> es invocado:
not_found do
'No existo'
end
=== Error
El manejador +error+ es invocado cada vez que una excepción es elevada
desde un bloque de ruta o un filtro. El objeto de la excepción se puede
obtener de la variable Rack <tt>sinatra.error</tt>:
error do
'Disculpá, ocurrió un error horrible - ' + env['sinatra.error'].name
end
Errores personalizados:
error MiErrorPersonalizado do
2011-04-17 10:43:22 +00:00
'Lo que pasó fue...' + env['sinatra.error'].message
2010-09-21 06:45:05 +00:00
end
Entonces, si pasa esto:
get '/' do
raise MiErrorPersonalizado, 'algo malo'
end
Obtenés esto:
Lo que pasó fue... algo malo
También, podés instalar un manejador de errores para un código de estado:
error 403 do
'Acceso prohibido'
end
get '/secreto' do
403
end
O un rango:
error 400..510 do
'Boom'
end
Sinatra instala manejadores <tt>not_found</tt> y <tt>error</ttt> especiales
cuando se ejecuta dentro del entorno de desarrollo "development".
== Rack Middleware
Sinatra corre sobre Rack[http://rack.rubyforge.org/], una interfaz minimalista
que es un estándar para frameworks webs escritos en Ruby. Una de las
capacidades más interesantes de Rack para los desarrolladores de aplicaciones
es el soporte de "middleware" -- componentes que se ubican entre el servidor y
tu aplicación, supervisando y/o manipulando la petición/respuesta HTTP para
proporcionar varios tipos de funcionalidades comunes.
Sinatra hace muy sencillo construir tuberías de Rack middleware a través del
método top-level +use+:
require 'sinatra'
require 'mi_middleware_personalizado'
use Rack::Lint
use MiMiddlewarePersonalizado
get '/hola' do
'Hola Mundo'
end
Las semánticas de +use+ son idénticas a las definidas para el DSL
2010-09-21 02:13:40 +00:00
Rack::Builder[http://rack.rubyforge.org/doc/classes/Rack/Builder.html] (más
frecuentemente usado desde archivos rackup). Por ejemplo, el método +use+
acepta argumentos múltiples/variables así como bloques:
2010-09-21 06:45:05 +00:00
use Rack::Auth::Basic do |nombre_de_usuario, password|
nombre_de_usuario == 'admin' && password == 'secreto'
end
Rack es distribuido con una variedad de middleware estándar para logging,
debugging, enrutamiento URL, autenticación, y manejo de sesiones. Sinatra
usa muchos de estos componentes automáticamente de acuerdo a su configuración
para que típicamente no tengas que usarlas (con +use+) explícitamente.
2011-05-24 22:06:48 +00:00
Podés encontrar middleware útil en
{rack}[https://github.com/rack/rack/tree/master/lib/rack],
{rack-contrib}[https://github.com/rack/rack-contrib#readme],
con {CodeRack}[http://coderack.org/] o en la
{Rack wiki}[https://github.com/rack/rack/wiki/List-of-Middleware].
2010-09-21 02:13:40 +00:00
== Pruebas
2010-09-21 06:45:05 +00:00
2010-09-21 02:13:40 +00:00
Las pruebas para las aplicaciones Sinatra pueden ser escritas utilizando
cualquier framework o librería de pruebas basada en Rack. Se recomienda usar
2011-05-24 22:09:21 +00:00
{Rack::Test}[http://rdoc.info/github/brynary/rack-test/master/frames]:
2010-09-21 06:45:05 +00:00
require 'mi_app_sinatra'
2010-09-30 19:12:21 +00:00
require 'test/unit'
2010-09-21 06:45:05 +00:00
require 'rack/test'
class MiAppTest < Test::Unit::TestCase
include Rack::Test::Methods
def app
Sinatra::Application
end
2010-09-21 02:13:40 +00:00
def test_mi_defecto
2010-09-21 06:45:05 +00:00
get '/'
assert_equal 'Hola Mundo!', last_response.body
end
def test_con_parametros
get '/saludar', :name => 'Franco'
2010-09-21 02:13:40 +00:00
assert_equal 'Hola Frank!', last_response.body
2010-09-21 06:45:05 +00:00
end
def test_con_entorno_rack
get '/', {}, 'HTTP_USER_AGENT' => 'Songbird'
assert_equal "Estás usando Songbird!", last_response.body
end
end
== Sinatra::Base - Middleware, Librerías, y Aplicaciones Modulares
Definir tu aplicación en el top-level funciona bien para micro-aplicaciones
pero trae inconvenientes considerables a la hora de construir componentes
2010-09-30 19:12:21 +00:00
reutilizables como Rack middleware, Rails metal, simple librerías con un
2010-09-21 06:45:05 +00:00
componente de servidor, o incluso extensiones de Sinatra. El DSL de top-level
contamina el espacio de nombres de Object y asume una configuración apropiada
para micro-aplicaciones (por ejemplo, un único archivo de aplicación, los
2011-05-24 21:59:04 +00:00
directorios <tt>./public</tt> y <tt>./views</tt>, logging, página con detalles
de excepción, etc.). Ahí es donde <tt>Sinatra::Base</tt> entra en el juego:
2010-09-21 06:45:05 +00:00
require 'sinatra/base'
class MiApp < Sinatra::Base
set :sessions, true
set :foo, 'bar'
get '/' do
'Hola Mundo!'
end
end
2011-05-24 21:59:04 +00:00
Las subclases de <tt>Sinatra::Base</tt> tienen disponibles exactamente los
mismos métodos que los provistos por el DSL de top-level. La mayoría de las
aplicaciones top-level se pueden convertir en componentes
<tt>Sinatra::Base</tt> con dos modificaciones:
2010-09-21 06:45:05 +00:00
2011-02-21 21:06:42 +00:00
* Tu archivo debe requerir <tt>sinatra/base</tt> en lugar de +sinatra+; de otra
2010-09-21 06:45:05 +00:00
manera, todos los métodos del DSL de sinatra son importados dentro del
espacio de nombres principal.
* Poné las rutas, manejadores de errores, filtros y opciones de tu aplicación
2011-05-24 21:59:04 +00:00
en una subclase de <tt>Sinatra::Base</tt>.
2010-09-21 06:45:05 +00:00
2010-10-12 15:31:59 +00:00
<tt>Sinatra::Base</tt> es una pizarra en blanco. La mayoría de las opciones están
2010-09-21 06:45:05 +00:00
desactivadas por defecto, incluyendo el servidor incorporado. Mirá
{Opciones y Configuraciones}[http://sinatra.github.com/configuration.html]
para detalles sobre las opciones disponibles y su comportamiento.
2011-02-21 21:06:42 +00:00
=== Estilo Modular vs. Clásico
Contrariamente a la creencia popular, no hay nada de malo con el estilo clásico.
Si se ajusta a tu aplicación, no es necesario que la cambies a una modular.
Existen tan solo dos desventajas en comparación con el estilo modular:
* Solamente podés tener una aplicación Sinatra por proceso Ruby - si tenés
planificado usar más, cambiá al estilo modular.
* El estilo clásico contamina Object con métodos delegadores - si tenés
planificado empaquetar tu aplicación en una librería/gem, cambiá al estilo
modular.
No hay ninguna razón por la cuál no puedas mezclar los estilos modular y
clásico.
Cuando cambiés de un estilo al otro, tené en cuenta las sutiles diferencias
entre sus configuraciones:
Configuración Clásica Modular
2011-05-24 22:16:37 +00:00
app_file archivo que carga sinatra archivo con la subclase de Sinatra::Base
2011-02-21 21:06:42 +00:00
run $0 == app_file false
logging true false
method_override true false
inline_templates true false
2011-04-19 23:12:07 +00:00
static true false
2011-02-21 21:06:42 +00:00
2011-01-12 23:05:26 +00:00
=== Sirviendo una Aplicación Modular
2011-01-10 15:45:52 +00:00
Las dos opciones más comunes para iniciar una aplicación modular son, iniciarla
activamente con <tt>run!</tt>:
# mi_app.rb
require 'sinatra/base'
class MiApp < Sinatra::Base
# ... código de la app ...
# iniciar el servidor si el archivo fue ejecutado directamente
run! if app_file == $0
end
Iniciar con:
ruby mi_app.rb
O, con un archivo <tt>config.ru</tt>, que permite usar cualquier handler Rack:
# config.ru
2011-06-01 09:52:09 +00:00
require './mi_app'
2011-01-10 15:45:52 +00:00
run MiApp
Después ejecutar:
rackup -p 4567
2011-01-12 23:05:26 +00:00
=== Usando una Aplicación Clásica con un Archivo config.ru
2011-01-10 15:45:52 +00:00
Escribí el archivo de tu aplicación:
# app.rb
require 'sinatra'
get '/' do
'Hola mundo!'
end
Y el <tt>config.ru</tt> correspondiente:
2011-06-01 09:52:09 +00:00
require './app'
2011-01-10 15:45:52 +00:00
run Sinatra::Application
2011-01-12 23:05:26 +00:00
=== ¿Cuándo Usar config.ru?
2011-01-10 15:45:52 +00:00
Indicadores de que probablemente querés usar <tt>config.ru</tt>:
* Querés realizar el deploy con un hanlder Rack distinto (Passenger, Unicorn,
Heroku, ...).
* Querés usar más de una subclase de <tt>Sinatra::Base</tt>.
* Querés usar Sinatra únicamente para middleware, pero no como un endpoint.
<b>No hay necesidad de utilizar un archivo <tt>config.ru</tt> exclusivamente
porque tenés una aplicación modular, y no necesitás una aplicación modular para
iniciarla con <tt>config.ru</tt>.</b>
2010-09-30 19:12:21 +00:00
=== Utilizando Sinatra como Middleware
Sinatra no solo es capaz de usar otro Rack middleware, sino que a su vez,
cualquier aplicación Sinatra puede ser agregada delante de un endpoint Rack
como middleware. Este endpoint puede ser otra aplicación Sinatra, o cualquier
2011-03-09 00:12:32 +00:00
aplicación basada en Rack (Rails/Ramaze/Camping/...):
2010-09-30 19:12:21 +00:00
require 'sinatra/base'
2010-12-20 16:04:20 +00:00
class PantallaDeLogin < Sinatra::Base
2010-11-07 08:49:23 +00:00
enable :sessions
2010-09-30 19:12:21 +00:00
get('/login') { haml :login }
post('/login') do
2011-05-24 22:20:45 +00:00
if params[:nombre] == 'admin' && params[:password] == 'admin'
2010-09-30 19:12:21 +00:00
session['nombre_de_usuario'] = params[:nombre]
else
redirect '/login'
end
end
end
class MiApp < Sinatra::Base
# el middleware se ejecutará antes que los filtros
use PantallaDeLogin
before do
unless session['nombre_de_usuario']
halt "Acceso denegado, por favor <a href='/login'>iniciá sesión</a>."
end
end
get('/') { "Hola #{session['nombre_de_usuario']}." }
end
2011-03-29 17:07:14 +00:00
=== Creación Dinámica de Aplicaciones
Puede que en algunas ocasiones quieras crear nuevas aplicaciones en
tiempo de ejecución sin tener que asignarlas a una constante. Para
2011-04-30 12:20:11 +00:00
esto tenés <tt>Sinatra.new</tt>:
2011-03-29 17:07:14 +00:00
require 'sinatra/base'
mi_app = Sinatra.new { get('/') { "hola" } }
mi_app.run!
Acepta como argumento opcional una aplicación desde la que se
heredará:
2011-07-01 23:55:08 +00:00
# config.ru
2011-03-29 17:07:14 +00:00
require 'sinatra/base'
controller = Sinatra.new do
enable :logging
helpers MisHelpers
end
map('/a') do
run Sinatra.new(controller) { get('/') { 'a' } }
end
map('/b') do
run Sinatra.new(controller) { get('/') { 'b' } }
end
Construir aplicaciones de esta forma resulta especialmente útil para
testear extensiones Sinatra o para usar Sinatra en tus librerías.
Por otro lado, hace extremadamente sencillo usar Sinatra como
middleware:
require 'sinatra/base'
use Sinatra do
get('/') { ... }
end
run ProyectoRails::Application
2010-09-30 19:12:21 +00:00
== Ámbitos y Ligaduras
El ámbito en el que te encontrás determina que métodos y variables están
disponibles.
=== Ámbito de Aplicación/Clase
2011-05-24 21:59:04 +00:00
Cada aplicación Sinatra es una subclase de <tt>Sinatra::Base</tt>. Si estás
usando el DSL de top-level (<tt>require 'sinatra'</tt>), entonces esta clase es
<tt>Sinatra::Application</tt>, de otra manera es la subclase que creaste
explícitamente. Al nivel de la clase tenés métodos como +get+ o +before+, pero
no podés acceder a los objetos +request+ o +session+, ya que hay una única
clase de la aplicación para todas las peticiones.
2010-09-30 19:12:21 +00:00
2011-02-21 21:06:42 +00:00
Las opciones creadas utilizando +set+ son métodos al nivel de la clase:
2010-09-30 19:12:21 +00:00
2010-11-10 19:15:51 +00:00
class MiApp < Sinatra::Base
2010-09-30 19:12:21 +00:00
# Ey, estoy en el ámbito de la aplicación!
set :foo, 42
foo # => 42
get '/foo' do
# Hey, ya no estoy en el ámbito de la aplicación!
end
end
Tenés la ligadura al ámbito de la aplicación dentro de:
* El cuerpo de la clase de tu aplicación
* Métodos definidos por extensiones
2011-02-21 21:06:42 +00:00
* El bloque pasado a +helpers+
* Procs/bloques usados como el valor para +set+
2010-09-30 19:12:21 +00:00
Este ámbito puede alcanzarse de las siguientes maneras:
* A través del objeto pasado a los bloques de configuración (<tt>configure { |c| ...}</tt>)
2011-02-21 21:06:42 +00:00
* Llamando a +settings+ desde dentro del ámbito de la petición
2010-09-30 19:12:21 +00:00
=== Ámbito de Petición/Instancia
Para cada petición entrante, una nueva instancia de la clase de tu aplicación
es creada y todos los bloques de rutas son ejecutados en ese ámbito. Desde este
2011-02-21 21:06:42 +00:00
ámbito podés acceder a los objetos +request+ y +session+ o llamar a los métodos
de renderización como +erb+ o +haml+. Podés acceder al ámbito de la aplicación
desde el ámbito de la petición utilizando +settings+:
2010-09-30 19:12:21 +00:00
2010-11-10 19:15:51 +00:00
class MiApp < Sinatra::Base
2010-09-30 19:12:21 +00:00
# Ey, estoy en el ámbito de la aplicación!
get '/definir_ruta/:nombre' do
# Ámbito de petición para '/definir_ruta/:nombre'
@valor = 42
settings.get("/#{params[:nombre]}") do
# Ámbito de petición para "/#{params[:nombre]}"
@valor # => nil (no es la misma petición)
end
"Ruta definida!"
end
end
Tenés la ligadura al ámbito de la petición dentro de:
2010-12-20 16:04:20 +00:00
* bloques pasados a get/head/post/put/delete/options
2010-09-30 19:12:21 +00:00
* filtros before/after
* métodos ayudantes
* plantillas/vistas
=== Ámbito de Delegación
El ámbito de delegación solo reenvía métodos al ámbito de clase. De cualquier
manera, no se comporta 100% como el ámbito de clase porque no tenés la ligadura
de la clase: únicamente métodos marcados explícitamente para delegación están
disponibles y no compartís variables/estado con el ámbito de clase (léase:
2011-02-21 21:06:42 +00:00
tenés un +self+ diferente). Podés agregar delegaciones de método llamando a
2010-09-30 19:12:21 +00:00
<tt>Sinatra::Delegator.delegate :nombre_del_metodo</tt>.
Tenés la ligadura al ámbito de delegación dentro de:
* La ligadura del top-level, si hiciste <tt>require "sinatra"</tt>
2011-02-21 21:06:42 +00:00
* Un objeto extendido con el mixin <tt>Sinatra::Delegator</tt>
2010-09-30 19:12:21 +00:00
2010-09-21 06:45:05 +00:00
Pegale una mirada al código: acá está el
{Sinatra::Delegator mixin}[http://github.com/sinatra/sinatra/blob/ceac46f0bc129a6e994a06100aa854f606fe5992/lib/sinatra/base.rb#L1128]
2010-09-30 19:12:21 +00:00
que es {incluido en el espacio de nombres principal}[http://github.com/sinatra/sinatra/blob/ceac46f0bc129a6e994a06100aa854f606fe5992/lib/sinatra/main.rb#L28].
2010-09-21 06:45:05 +00:00
2011-01-12 23:05:26 +00:00
== Línea de Comandos
2010-09-21 06:45:05 +00:00
Las aplicaciones Sinatra pueden ser ejecutadas directamente:
ruby miapp.rb [-h] [-x] [-e ENTORNO] [-p PUERTO] [-o HOST] [-s MANEJADOR]
Las opciones son:
-h # ayuda
-p # asigna el puerto (4567 es usado por defecto)
-o # asigna el host (0.0.0.0 es usado por defecto)
-e # asigna el entorno (development es usado por defecto)
-s # especifica el servidor/manejador rack (thin es usado por defecto)
-x # activa el mutex lock (está desactivado por defecto)
2011-03-20 18:00:12 +00:00
== Versiones de Ruby Soportadas
2011-02-21 21:06:42 +00:00
Las siguientes versiones de Ruby son soportadas oficialmente:
[ Ruby 1.8.7 ]
1.8.7 es soportado completamente. Sin embargo, si no hay nada que te lo
2011-09-03 02:17:07 +00:00
prohíba, te recomendamos que usés 1.9.2 o cambies a JRuby o Rubinius. No se
dejará de dar soporte a 1.8.7 hasta Sinatra 2.0 y Ruby 2.0, aunque si se
libera la versión 1.8.8 de Ruby las cosas podrían llegar a cambiar. Sin
embargo, que eso ocurra es muy poco probable, e incluso el caso de que lo
haga, puede que se siga dando soporte a 1.8.7. <b>Hemos dejado de soportar
Ruby 1.8.6.</b> Si querés ejecutar Sinatra sobre 1.8.6, podés utilizar la
versión 1.2, pero tené en cuenta que una vez que Sinatra 1.4.0 sea liberado,
ya no se corregirán errores por más que se reciban reportes de los mismos.
2011-02-21 21:06:42 +00:00
[ Ruby 1.9.2 ]
1.9.2 es soportado y recomendado. Tené en cuenta que Radius y Markaby no
son compatibles con 1.9 actualmente. Además, no usés 1.9.2p0, porque produce
2011-05-24 22:25:36 +00:00
fallos de segmentación cuando se ejecuta Sinatra.
2011-02-21 21:06:42 +00:00
[ Rubinius ]
2011-09-03 02:17:07 +00:00
Rubinius es soportado oficialmente (Rubinius >= 1.2.4). Todo
2011-03-18 17:08:00 +00:00
funciona correctamente, incluyendo los lenguajes de plantillas.
2011-02-21 21:06:42 +00:00
[ JRuby ]
2011-09-03 02:17:07 +00:00
JRuby es soportado oficialmente (JRuby >= 1.6.3). No se conocen
2011-03-18 17:08:00 +00:00
problemas con librerías de plantillas de terceras partes. Sin
embargo, si elegís usar JRuby, deberías examinar sus Rack handlers
porque el servidor web Thin no es soportado completamente. El
soporte de JRuby para extensiones C se encuentra en una etapa
2011-05-24 22:29:34 +00:00
experimental, sin embargo, de momento solamente RDiscount y Redcarpted
se ven afectadas.
2011-02-21 21:06:42 +00:00
Siempre le prestamos atención a las nuevas versiones de Ruby.
Las siguientes implementaciones de Ruby no se encuentran soportadas
oficialmente. De cualquier manera, pueden ejecutar Sinatra:
* Versiones anteriores de JRuby y Rubinius
2011-09-03 02:17:07 +00:00
* Ruby Enterprise Edition
2011-03-18 17:08:00 +00:00
* MacRuby, Maglev e IronRuby
2011-09-03 02:17:07 +00:00
* Ruby 1.9.0 y 1.9.1 (pero no te recomendamos que los usés)
2011-02-21 21:06:42 +00:00
No estar soportada oficialmente, significa que si las cosas solamente se rompen
ahí y no en una plataforma soportada, asumimos que no es nuestro problema sino
el suyo.
2011-03-18 17:08:00 +00:00
Nuestro servidor CI también se ejecuta sobre ruby-head (que será la
2011-09-03 02:17:07 +00:00
próxima versión 1.9.4). Como está en movimiento constante, no podemos
garantizar nada. De todas formas, podés contar con que 1.9.4-p0 sea
2011-03-18 17:08:00 +00:00
soportada.
2011-02-21 21:06:42 +00:00
Sinatra debería funcionar en cualquier sistema operativo soportado por la
implementación de Ruby elegida.
2011-09-03 02:17:07 +00:00
En este momento, no vas a poder ejecutar Sinatra en Cardinal, SmallRuby,
BlueRuby o cualquier versión de Ruby anterior a 1.8.7.
2011-01-12 23:05:26 +00:00
== A la Vanguardia
2011-01-12 23:24:25 +00:00
Si querés usar el código de Sinatra más reciente, sentite libre de ejecutar
tu aplicación sobre la rama master, en general es bastante estable.
También liberamos prereleases de vez en cuando, así, podés hacer
gem install sinatra --pre
Para obtener algunas de las últimas características.
2011-01-12 23:16:24 +00:00
=== Con Bundler
Esta es la manera recomendada para ejecutar tu aplicación sobre la última
versión de Sinatra usando {Bundler}[http://gembundler.com/].
Primero, instalá bundler si no lo hiciste todavía:
gem install bundler
Después, en el directorio de tu proyecto, creá un archivo +Gemfile+:
source :rubygems
gem 'sinatra', :git => "git://github.com/sinatra/sinatra.git"
# otras dependencias
gem 'haml' # por ejemplo, si usás haml
gem 'activerecord', '~> 3.0' # quizás también necesités ActiveRecord 3.x
Tené en cuenta que tenés que listar todas las dependencias directas de tu
aplicación. No es necesario listar las dependencias de Sinatra (Rack y Tilt)
porque Bundler las agrega directamente.
Ahora podés arrancar tu aplicación así:
bundle exec ruby miapp.rb
=== Con Git
2010-09-21 06:45:05 +00:00
2011-01-12 23:24:25 +00:00
Cloná el repositorio localmente y ejecutá tu aplicación, asegurándote que el
2011-02-21 21:06:42 +00:00
directorio <tt>sinatra/lib</tt> esté en el <tt>$LOAD_PATH</tt>:
2010-09-21 06:45:05 +00:00
cd miapp
git clone git://github.com/sinatra/sinatra.git
ruby -Isinatra/lib miapp.rb
Para actualizar el código fuente de Sinatra en el futuro:
2011-01-12 23:17:30 +00:00
cd miapp/sinatra
2010-09-21 06:45:05 +00:00
git pull
2011-01-12 23:24:25 +00:00
=== Instalación Global
Podés construir la gem vos mismo:
git clone git://github.com/sinatra/sinatra.git
cd sinatra
rake sinatra.gemspec
rake install
Si instalás tus gems como root, el último paso debería ser
sudo rake install
2011-03-09 00:12:32 +00:00
== Versionado
Sinatra utiliza el {Versionado Semántico}[http://semver.org/],
siguiendo las especificaciones SemVer y SemVerTag.
2011-01-12 23:05:26 +00:00
== Lecturas Recomendadas
2010-09-21 06:45:05 +00:00
* {Sito web del proyecto}[http://www.sinatrarb.com/] - Documentación
adicional, noticias, y enlaces a otros recursos.
* {Contribuyendo}[http://www.sinatrarb.com/contributing] - ¿Encontraste un
error?. ¿Necesitás ayuda?. ¿Tenés un parche?.
2010-09-30 19:12:21 +00:00
* {Seguimiento de problemas}[http://github.com/sinatra/sinatra/issues]
2010-09-21 06:45:05 +00:00
* {Twitter}[http://twitter.com/sinatra]
* {Lista de Correo}[http://groups.google.com/group/sinatrarb/topics]
* {IRC: #sinatra}[irc://chat.freenode.net/#sinatra] en http://freenode.net
2011-05-24 22:43:54 +00:00
* {Sinatra Book}[http://sinatra-book.gittr.com] Tutorial (en inglés).
2011-10-14 22:12:40 +00:00
* {Sinatra Recipes}[http://recipes.sinatrarb.com/] Recetas contribuidas
2011-05-24 22:43:54 +00:00
por la comunidad (en inglés).
2011-04-14 16:05:49 +00:00
* Documentación de la API para la
{última versión liberada}[http://rubydoc.info/gems/sinatra] o para la
{rama de desarrollo actual}[http://rubydoc.info/github/sinatra/sinatra]
en http://rubydoc.info/
2011-07-31 22:31:33 +00:00
* {Servidor de IC}[http://ci.rkh.im/view/Sinatra/]