kotovalexarian-likes-github
/
sinatra
mirror of https://github.com/sinatra/sinatra
1
0
Fork 0
Code Releases Activity
sinatra/README.pt-br.md

3788 lines
98 KiB
Markdown
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

# Sinatra
*Atenção: Este documento é apenas uma tradução da versão em inglês e
pode estar desatualizado.*
Alguns dos trechos de código a seguir utilizam caracteres UTF-8. Então, caso
esteja utilizando uma versão de ruby inferior à `2.0.0`, adicione o encoding
no início de seus arquivos:
```ruby
# encoding: utf-8
```
Sinatra é uma
[DSL](https://pt.wikipedia.org/wiki/Linguagem_de_domínio_específico) para
criar aplicações web em Ruby com o mínimo de esforço e rapidez:
```ruby
# minha_app.rb
require 'sinatra'
get '/' do
'Olá Mundo!'
end
```
Instale a gem:
```shell
gem install sinatra
```
Em seguida execute:
```shell
ruby minha_app.rb
```
Acesse em: [http://localhost:4567](http://localhost:4567)
Códigos alterados só terão efeito após você reiniciar o servidor.
Por favor, reinicie o servidor após qualquer mudança ou use
[sinatra/reloader](http://www.sinatrarb.com/contrib/reloader).
É recomendado também executar `gem install thin`. Caso esta gem esteja
disponível, o Sinatra irá utilizá-la.
## Conteúdo
* [Sinatra](#sinatra)
* [Conteúdo](#conteúdo)
* [Rotas](#rotas)
* [Condições](#condições)
* [Valores Retornados](#valores-retornados)
* [Validadores de rota personalizados](#validadores-de-rota-personalizados)
* [Arquivos estáticos](#arquivos-estáticos)
* [Views / Templates](#views--templates)
* [Literal Templates](#literal-templates)
* [Linguagens de template disponíveis](#linguagens-de-template-disponíveis)
* [Haml Templates](#haml-templates)
* [Erb Templates](#erb-templates)
* [Builder Templates](#builder-templates)
* [Nokogiri Templates](#nokogiri-templates)
* [Sass Templates](#sass-templates)
* [SCSS Templates](#scss-templates)
* [Less Templates](#less-templates)
* [Liquid Templates](#liquid-templates)
* [Markdown Templates](#markdown-templates)
* [Textile Templates](#textile-templates)
* [RDoc Templates](#rdoc-templates)
* [AsciiDoc Templates](#asciidoc-templates)
* [Radius Templates](#radius-templates)
* [Markaby Templates](#markaby-templates)
* [RABL Templates](#rabl-templates)
* [Slim Templates](#slim-templates)
* [Creole Templates](#creole-templates)
* [MediaWiki Templates](#mediawiki-templates)
* [CoffeeScript Templates](#coffeescript-templates)
* [Stylus Templates](#stylus-templates)
* [Yajl Templates](#yajl-templates)
* [WLang Templates](#wlang-templates)
* [Acessando Variáveis nos Templates](#acessando-variáveis-nos-templates)
* [Templates com `yield` e layouts aninhados](#templates-com-yield-e-layouts-aninhados)
* [Templates Inline](#templates-inline)
* [Templates Nomeados](#templates-nomeados)
* [Associando extensões de arquivos](#associando-extensões-de-arquivos)
* [Adicionando seu Próprio Engine de Template](#adicionando-seu-próprio-engine-de-template)
* [Customizando lógica para encontrar templates](#customizando-lógica-para-encontrar-templates)
* [Filtros](#filtros)
* [Helpers](#helpers)
* [Utilizando Sessões](#utilizando-sessões)
* [Segurança Secreta da Sessão](#segurança-secreta-da-sessão)
* [Configuração da Sessão](#configuração-da-sessão)
* [Escolhande Seu Próprio Middleware de Sessão](#escolhendo-middleware-de-sessão)
* [Halting](#halting)
* [Passing](#passing)
* [Desencadeando Outra Rota](#desencadeando-outra-rota)
* [Definindo Corpo, Código de Status e Cabeçalhos](#definindo-corpo-codigo-de-status-cabeçalhos)
* [Transmitindo Respostas](#transmitindo-respostas)
* [Usando Logs](#usando-logs)
* [Tipos Mime](#tipos-mime)
* [Gerando URLS](#gerando-urls)
* [Redirecionamento do Navegador](#redirecionamento-do-navagador)
* [Controle de Cache](#controle-de-cache)
* [Enviando Arquivos](#enviando-arquivos)
* [Acessando o Objeto de Requisição](#acessando-o-objeto-de-requisição)
* [Anexos](#anexos)
* [Trabalhando com Data e Hora](#trabalhando-com-data-e-hora)
* [Procurando Arquivos de Modelo](#procurando-arquivos-de-modelo)
* [Configuração](#configuração)
* [Configurando proteção a ataques](#configurando-proteção-a-ataques)
* [Configurações Disponíveis](#configurações-disponíveis)
* [Ambientes](#ambientes)
* [Tratamento de Erros](#tratamento-de-erros)
* [Não Encontrado](#não-encontrado)
* [Erro](#erro)
* [Rack Middleware](#rack-middleware)
* [Testando](#testando)
* [Sinatra::Base - Middleware, Bibliotecas e Aplicações Modulares](#sinatrabase-middleware-bibliotecas-e-aplicações-modulares)
* [Modular vs. Estilo Clássico](#modular-vs-estilo-clássico)
* [Servindo uma Aplicação Modular](#servindo-uma-aplicação-modular)
* [Usando uma Aplicação de Estilo Clássico com um config.ru](#usando-uma-aplicação-de-estilo-clássico-com-um-configru)
* [Quando usar um config.ru?](#quando-usar-um-configru)
* [Usando Sinatra como Middleware](#usando-sinatra-como-middleware)
* [Criação de Aplicações Dinâmicas](#criação-de-aplicações-dinamicas)
* [Escopos e Ligação](#escopos-e-ligação)
* [Escopo de Aplicação/Classe](#escopo-de-aplicação-classe)
* [Escopo de Instância/Requisição](#escopo-de-instância-requisição)
* [Escopo de Delegação](#escopo-de-delegação)
* [Linha de comando](#linha-de-comando)
* [Multi-threading](#multi-threading)
* [Requerimentos](#requerimentos)
* [A última versão](#a-última-versão)
* [Com Bundler](#com-bundler)
* [Versionando](#versionando)
* [Mais](#mais)
## Rotas
No Sinatra, uma rota é um método HTTP emparelhado com um padrão de URL.
Cada rota possui um bloco de execução:
```ruby
get '/' do
.. mostrando alguma coisa ..
end
post '/' do
.. criando alguma coisa ..
end
put '/' do
.. atualizando alguma coisa ..
end
patch '/' do
.. modificando alguma coisa ..
end
delete '/' do
.. removendo alguma coisa ..
end
options '/' do
.. estabelecendo alguma coisa ..
end
link '/' do
.. associando alguma coisa ..
end
unlink '/' do
.. separando alguma coisa ..
end
```
As rotas são interpretadas na ordem em que são definidas. A primeira
rota encontrada responde a requisição.
Rotas com barras à direita são diferentes das que não contém as barras:
```ruby
get '/foo' do
# Não é o mesmo que "GET /foo/"
end
```
Padrões de rota podem conter parâmetros nomeados, acessíveis por meio do
hash `params`:
```ruby
get '/ola/:nome' do
# corresponde a "GET /ola/foo" e "GET /ola/bar"
# params['nome'] é 'foo' ou 'bar'
"Olá #{params['nome']}!"
end
```
Você também pode acessar parâmetros nomeados por meio dos parâmetros de
um bloco:
```ruby
get '/ola/:nome' do |n|
# corresponde a "GET /ola/foo" e "GET /ola/bar"
# params['nome'] é 'foo' ou 'bar'
# n guarda o valor de params['nome']
"Olá #{n}!"
end
```
Padrões de rota também podem conter parâmetros splat (curinga),
acessível por meio do array `params['splat']`:
```ruby
get '/diga/*/para/*' do
# corresponde a /diga/ola/para/mundo
params['splat'] # => ["ola", "mundo"]
end
get '/download/*.*' do
# corresponde a /download/caminho/do/arquivo.xml
params['splat'] # => ["caminho/do/arquivo", "xml"]
end
```
Ou com parâmetros de um bloco:
```ruby
get '/download/*.*' do |caminho, ext|
[caminho, ext] # => ["caminho/do/arquivo", "xml"]
end
```
Rotas podem casar com expressões regulares:
```ruby
get /\/ola\/([\w]+)/ do
"Olá, #{params['captures'].first}!"
end
```
Ou com parâmetros de um bloco:
```ruby
get %r{/ola/([\w]+)} do |c|
# corresponde a "GET /meta/ola/mundo", "GET /ola/mundo/1234" etc.
"Olá, #{c}!"
end
```
Padrões de rota podem contar com parâmetros opcionais:
```ruby
get '/posts/:formato?' do
# corresponde a "GET /posts/" e qualquer extensão "GET /posts/json", "GET /posts/xml", etc.
end
```
Rotas também podem utilizar query strings:
```ruby
get '/posts' do
# corresponde a "GET /posts?titulo=foo&autor=bar"
titulo = params['titulo']
autor = params['autor']
# utiliza as variáveis titulo e autor; a query é opcional para a rota /posts
end
```
A propósito, a menos que você desative a proteção contra ataques (veja
[abaixo](#configurando-proteção-a-ataques)), o caminho solicitado pode ser
alterado antes de concluir a comparação com as suas rotas.
Você pode customizar as opções usadas do
[Mustermann](https://github.com/sinatra/mustermann#readme) para uma
rota passando `:mustermann_opts` num hash:
```ruby
get '\A/posts\z', :musterman_opts => { :type => regexp, :check_anchors => false } do
# corresponde a /posts exatamente, com ancoragem explícita
"Se você combinar um padrão ancorado bata palmas!"
end
```
Parece com uma [condição](#condições) mas não é! Essas opções serão
misturadas no hash global `:mustermann_opts` descrito
[abaixo](#configurações-disponíveis)
## Condições
Rotas podem incluir uma variedade de condições, tal como o `user agent`:
```ruby
get '/foo', :agent => /Songbird (\d\.\d)[\d\/]*?/ do
"Você está usando o Songbird versão #{params['agent'][0]}"
end
get '/foo' do
# Correspondente a navegadores que não sejam Songbird
end
```
Outras condições disponíveis são `host_name` e `provides`:
```ruby
get '/', :host_name => /^admin\./ do
"Área administrativa. Acesso negado!"
end
get '/', :provides => 'html' do
haml :index
end
get '/', :provides => ['rss', 'atom', 'xml'] do
builder :feed
end
```
`provides` procura o cabeçalho Accept das requisições
Você pode facilmente definir suas próprias condições:
```ruby
set(:probabilidade) { |valor| condition { rand <= valor } }
get '/ganha_um_carro', :probabilidade => 0.1 do
"Você ganhou!"
end
get '/ganha_um_carro' do
"Sinto muito, você perdeu."
end
```
Use splat, para uma condição que leva vários valores:
```ruby
set(:auth) do |*roles| # <- observe o splat aqui
condition do
unless logged_in? && roles.any? {|role| current_user.in_role? role }
redirect "/login/", 303
end
end
end
get "/minha/conta/", :auth => [:usuario, :administrador] do
"Detalhes da sua conta"
end
get "/apenas/administrador/", :auth => :administrador do
"Apenas administradores são permitidos aqui!"
end
```
## Retorno de valores
O valor de retorno do bloco de uma rota determina pelo menos o corpo da
resposta passado para o cliente HTTP, ou pelo menos o próximo middleware
na pilha Rack. Frequentemente, isto é uma `string`, tal como nos
exemplos acima. Entretanto, outros valores também são aceitos.
Você pode retornar uma resposta válida ou um objeto para o Rack, sendo
eles de qualquer tipo de objeto que queira. Além disso, é possível
retornar um código de status HTTP.
* Um array com três elementos: `[status (Integer), cabeçalho (Hash),
corpo da resposta (responde à #each)]`
* Um array com dois elementos: `[status (Integer), corpo da resposta
(responde à #each)]`
* Um objeto que responda à `#each` sem passar nada, mas, sim, `strings`
para um dado bloco
* Um objeto `Integer` representando o código de status
Dessa forma, podemos implementar facilmente um exemplo de streaming:
```ruby
class Stream
def each
100.times { |i| yield "#{i}\n" }
end
end
get('/') { Stream.new }
```
Você também pode usar o método auxiliar `stream`
([descrito abaixo](#respostas-de-streaming)) para reduzir códigos
boilerplate e para incorporar a lógica de streaming (transmissão) na rota.
## Validadores de Rota Personalizados
Como apresentado acima, a estrutura do Sinatra conta com suporte
embutido para uso de padrões de String e expressões regulares como
validadores de rota. No entanto, ele não pára por aí. Você pode
facilmente definir os seus próprios validadores:
```ruby
class AllButPattern
Match = Struct.new(:captures)
def initialize(except)
@except = except
@captures = Match.new([])
end
def match(str)
@captures unless @except === str
end
end
def all_but(pattern)
AllButPattern.new(pattern)
end
get all_but("/index") do
# ...
end
```
Note que o exemplo acima pode ser robusto e complicado em excesso. Pode
também ser implementado como:
```ruby
get // do
pass if request.path_info == "/index"
# ...
end
```
Ou, usando algo mais denso à frente:
```ruby
get %r{(?!/index)} do
# ...
end
```
## Arquivos estáticos
Arquivos estáticos são disponibilizados a partir do diretório
`./public`. Você pode especificar um local diferente pela opção
`:public_folder`
```ruby
set :public_folder, __dir__ + '/estatico'
```
Note que o nome do diretório público não é incluído na URL. Um arquivo
`./public/css/style.css` é disponibilizado como
`http://exemplo.com/css/style.css`.
Use a configuração `:static_cache_control` (veja [abaixo](#controle-de-cache))
para adicionar a informação `Cache-Control` no cabeçalho.
## Views / Templates
Cada linguagem de template é exposta através de seu próprio método de
renderização. Estes métodos simplesmente retornam uma string:
```ruby
get '/' do
erb :index
end
```
Isto renderiza `views/index.rb`
Ao invés do nome do template, você também pode passar direto o conteúdo do
template:
```ruby
get '/' do
code = "<%= Time.now %>"
erb code
end
```
Templates também aceitam como um segundo argumento, um hash de opções:
```ruby
get '/' do
erb :index, :layout => :post
end
```
Isto irá renderizar a `views/index.erb` inclusa dentro da `views/post.erb`
(o padrão é a `views/layout.erb`, se existir).
Qualquer opção não reconhecida pelo Sinatra será passada adiante para o engine
de template:
```ruby
get '/' do
haml :index, :format => :html5
end
```
Você também pode definir opções padrões para um tipo de template:
```ruby
set :haml, :format => :html5
get '/' do
haml :index
end
```
Opções passadas para o método de renderização sobrescreve as opções definitas
através do método `set`.
Opções disponíveis:
<dl>
<dt>locals</dt>
<dd>
Lista de locais passado para o documento. Conveniente para *partials*
Exemplo: <tt>erb "<%= foo %>", :locals => {:foo => "bar"}</tt>
</dd>
<dt>default_encoding</dt>
<dd>
String encoding para ser utilizada em caso de incerteza. o padrão é
<tt>settings.default_encoding</tt>.
</dd>
<dt>views</dt>
<dd>
Diretório de onde os templates são carregados. O padrão é
<tt>settings.views</tt>.
</dd>
<dt>layout</dt>
<dd>
Para definir quando utilizar ou não um
layout (<tt>true</tt> ou <tt>false</tt>). E se for um
Symbol, especifica qual template usar. Exemplo:
<tt>erb :index, :layout => !request.xhr?</tt>
</dd>
<dt>content_type</dt>
<dd>
O *Content-Type* que o template produz. O padrão depende
da linguagem de template utilizada.
</dd>
<dt>scope</dt>
<dd>
Escopo em que o template será renderizado. Padrão é a
instância da aplicação. Se você mudar isto as variáveis
de instância métodos auxiliares não serão
disponibilizados.
</dd>
<dt>layout_engine</dt>
<dd>
A engine de template utilizada para renderizar seu layout.
Útil para linguagens que não suportam templates de outra
forma. O padrão é a engine do template utilizado. Exemplo:
<tt>set :rdoc, :layout_engine => :erb</tt>
</dd>
<dt>layout_options</dt>
<dd>
Opções especiais utilizadas apenas para renderizar o
layout. Exemplo:
<tt>set :rdoc, :layout_options => { :views => 'views/layouts' }</tt>
</dd>
</dl>
É pressuposto que os templates estarão localizados diretamente sob o
diretório `./views`. Para usar um diretório diferente:
```ruby
set :views, settings.root + '/templates'
```
Uma coisa importante para se lembrar é que você sempre deve
referenciar os templates utilizando *symbols*, mesmo que
eles estejam em um subdiretório (neste caso use:
`:'subdir/template'` or `'subdir/template'.to_sym`). Você deve
utilizar um *symbol* porque senão o método de renderização irá
renderizar qualquer outra string que você passe diretamente
para ele
### Literal Templates
```ruby
get '/' do
haml '%div.title Olá Mundo'
end
```
Renderiza um template string. Você pode opcionalmente especificar `path`
e `:line` para um backtrace mais claro se existir um caminho do sistema de
arquivos ou linha associada com aquela string.
```ruby
get '/' do
haml '%div.title Olá Mundo', :path => 'exemplos/arquivo.haml', :line => 3
end
```
### Linguagens de template disponíveis
Algumas linguagens possuem múltiplas implementações. Para especificar qual
implementação deverá ser utilizada (e para ser *thread-safe*), você deve
requerê-la primeiro:
```ruby
require 'rdiscount' # ou require 'bluecloth'
get('/') { markdown :index }
```
#### Haml Templates
<table>
<tr>
<td>Dependência</td>
<td><a href="http://haml.info/" title="haml">haml</a></td>
</tr>
<tr>
<td>Extensão do Arquivo</td>
<td><tt>.haml</tt></td>
</tr>
<tr>
<td>Exemplo</td>
<td><tt>haml :index, :format => :html5</tt></td>
</tr>
</table>
#### Erb Templates
<table>
<tr>
<td>Dependência</td>
<td>
<a href="http://www.kuwata-lab.com/erubis/" title="erubis">erubis</a>
or erb (included in Ruby)
</td>
</tr>
<tr>
<td>Extensão dos Arquivos</td>
<td><tt>.erb</tt>, <tt>.rhtml</tt> or <tt>.erubis</tt> (Erubis only)</td>
</tr>
<tr>
<td>Exemplo</td>
<td><tt>erb :index</tt></td>
</tr>
</table>
#### Builder Templates
<table>
<tr>
<td>Dependência</td>
<td>
<a href="https://github.com/jimweirich/builder" title="builder">
builder
</a>
</td>
</tr>
<tr>
<td>Extensão do Arquivo</td>
<td><tt>.builder</tt></td>
</tr>
<tr>
<td>Exemplo</td>
<td><tt>builder { |xml| xml.em "hi" }</tt></td>
</tr>
</table>
It also takes a block for inline templates (see exemplo).
#### Nokogiri Templates
<table>
<tr>
<td>Dependência</td>
<td><a href="http://www.nokogiri.org/" title="nokogiri">nokogiri</a></td>
</tr>
<tr>
<td>Extensão do Arquivo</td>
<td><tt>.nokogiri</tt></td>
</tr>
<tr>
<td>Exemplo</td>
<td><tt>nokogiri { |xml| xml.em "hi" }</tt></td>
</tr>
</table>
It also takes a block for inline templates (see exemplo).
#### Sass Templates
<table>
<tr>
<td>Dependência</td>
<td><a href="http://sass-lang.com/" title="sass">sass</a></td>
</tr>
<tr>
<td>Extensão do Arquivo</td>
<td><tt>.sass</tt></td>
</tr>
<tr>
<td>Exemplo</td>
<td><tt>sass :stylesheet, :style => :expanded</tt></td>
</tr>
</table>
#### SCSS Templates
<table>
<tr>
<td>Dependência</td>
<td><a href="http://sass-lang.com/" title="sass">sass</a></td>
</tr>
<tr>
<td>Extensão do Arquivo</td>
<td><tt>.scss</tt></td>
</tr>
<tr>
<td>Exemplo</td>
<td><tt>scss :stylesheet, :style => :expanded</tt></td>
</tr>
</table>
#### Less Templates
<table>
<tr>
<td>Dependência</td>
<td><a href="http://lesscss.org/" title="less">less</a></td>
</tr>
<tr>
<td>Extensão do Arquivo</td>
<td><tt>.less</tt></td>
</tr>
<tr>
<td>Exemplo</td>
<td><tt>less :stylesheet</tt></td>
</tr>
</table>
#### Liquid Templates
<table>
<tr>
<td>Dependência</td>
<td>
<a href="https://shopify.github.io/liquid/" title="liquid">liquid</a>
</td>
</tr>
<tr>
<td>Extensão do Arquivo</td>
<td><tt>.liquid</tt></td>
</tr>
<tr>
<td>Exemplo</td>
<td><tt>liquid :index, :locals => { :key => 'value' }</tt></td>
</tr>
</table>
Já que você não pode chamar o Ruby (exceto pelo método `yield`) pelo template
Liquid, você quase sempre precisará passar o `locals` para ele.
#### Markdown Templates
<table>
<tr>
<td>Dependência</td>
<td>
Anyone of:
<a href="https://github.com/davidfstr/rdiscount" title="RDiscount">
RDiscount
</a>,
<a href="https://github.com/vmg/redcarpet" title="RedCarpet">
RedCarpet
</a>,
<a href="https://github.com/ged/bluecloth" title="bluecloth">
BlueCloth
</a>,
<a href="http://kramdown.gettalong.org/" title="kramdown">
kramdown
</a>,
<a href="https://github.com/bhollis/maruku" title="maruku">
maruku
</a>
</td>
</tr>
<tr>
<td>Extensão do Arquivos</td>
<td><tt>.markdown</tt>, <tt>.mkd</tt> and <tt>.md</tt></td>
</tr>
<tr>
<td>Exemplo</td>
<td><tt>markdown :index, :layout_engine => :erb</tt></td>
</tr>
</table>
Não é possível chamar métodos por este template, nem passar *locals* para o
mesmo. Portanto normalmente é utilizado junto a outra engine de renderização:
```ruby
erb :overview, :locals => { :text => markdown(:introducao) }
```
Note que você também pode chamar o método `markdown` dentro de outros templates:
```ruby
%h1 Olá do Haml!
%p= markdown(:saudacoes)
```
Já que você não pode chamar o Ruby pelo Markdown, você não
pode utilizar um layout escrito em Markdown. Contudo é
possível utilizar outra engine de renderização como template,
deve-se passar a `:layout_engine` como opção.
<table>
<tr>
<td>Dependência</td>
<td><a href="http://redcloth.org/" title="RedCloth">RedCloth</a></td>
</tr>
<tr>
<td>Extensão do Arquivo</td>
<td><tt>.textile</tt></td>
</tr>
<tr>
<td>Exemplo</td>
<td><tt>textile :index, :layout_engine => :erb</tt></td>
</tr>
</table>
Não é possível chamar métodos por este template, nem passar *locals* para o
mesmo. Portanto normalmente é utilizado junto a outra engine de renderização:
```ruby
erb :overview, :locals => { :text => textile(:introducao) }
```
Note que você também pode chamar o método `textile` dentro de outros templates:
```ruby
%h1 Olá do Haml!
%p= textile(:saudacoes)
```
Já que você não pode chamar o Ruby pelo Textile, você não
pode utilizar um layout escrito em Textile. Contudo é
possível utilizar outra engine de renderização como template,
deve-se passar a `:layout_engine` como opção.
#### RDoc Templates
<table>
<tr>
<td>Dependência</td>
<td><a href="http://rdoc.sourceforge.net/" title="RDoc">RDoc</a></td>
</tr>
<tr>
<td>Extensão do Arquivo</td>
<td><tt>.rdoc</tt></td>
</tr>
<tr>
<td>Exemplo</td>
<td><tt>rdoc :README, :layout_engine => :erb</tt></td>
</tr>
</table>
Não é possível chamar métodos por este template, nem passar *locals* para o
mesmo. Portanto normalmente é utilizado junto a outra engine de renderização:
```ruby
erb :overview, :locals => { :text => rdoc(:introducao) }
```
Note que você também pode chamar o método `rdoc` dentro de outros templates:
```ruby
%h1 Olá do Haml!
%p= rdoc(:saudacoes)
```
Já que você não pode chamar o Ruby pelo RDoc, você não
pode utilizar um layout escrito em RDoc. Contudo é
possível utilizar outra engine de renderização como template,
deve-se passar a `:layout_engine` como opção.
#### AsciiDoc Templates
<table>
<tr>
<td>Dependência</td>
<td>
<a href="http://asciidoctor.org/" title="Asciidoctor">Asciidoctor</a>
</td>
</tr>
<tr>
<td>Extensão do Arquivo</td>
<td><tt>.asciidoc</tt>, <tt>.adoc</tt> and <tt>.ad</tt></td>
</tr>
<tr>
<td>Exemplo</td>
<td><tt>asciidoc :README, :layout_engine => :erb</tt></td>
</tr>
</table>
Já que você não pode chamar o Ruby pelo template AsciiDoc,
você quase sempre precisará passar o `locals` para ele.
#### Radius Templates
<table>
<tr>
<td>Dependência</td>
<td><a href="https://github.com/jlong/radius" title="Radius">Radius</a></td>
</tr>
<tr>
<td>Extensão do Arquivo</td>
<td><tt>.radius</tt></td>
</tr>
<tr>
<td>Exemplo</td>
<td><tt>radius :index, :locals => { :key => 'value' }</tt></td>
</tr>
</table>
Já que você não pode chamar o Ruby pelo template Radius,
você quase sempre precisará passar o `locals` para ele.
#### Markaby Templates
<table>
<tr>
<td>Dependência</td>
<td><a href="http://markaby.github.io/" title="Markaby">Markaby</a></td>
</tr>
<tr>
<td>Extensão do Arquivo</td>
<td><tt>.mab</tt></td>
</tr>
<tr>
<td>Exemplo</td>
<td><tt>markaby { h1 "Welcome!" }</tt></td>
</tr>
</table>
Este também recebe um bloco para templates (veja o exemplo).
#### RABL Templates
<table>
<tr>
<td>Dependência</td>
<td><a href="https://github.com/nesquena/rabl" title="Rabl">Rabl</a></td>
</tr>
<tr>
<td>Extensão do Arquivo</td>
<td><tt>.rabl</tt></td>
</tr>
<tr>
<td>Exemplo</td>
<td><tt>rabl :index</tt></td>
</tr>
</table>
#### Slim Templates
<table>
<tr>
<td>Dependência</td>
<td><a href="http://slim-lang.com/" title="Slim Lang">Slim Lang</a></td>
</tr>
<tr>
<td>Extensão do Arquivo</td>
<td><tt>.slim</tt></td>
</tr>
<tr>
<td>Exemplo</td>
<td><tt>slim :index</tt></td>
</tr>
</table>
#### Creole Templates
<table>
<tr>
<td>Dependência</td>
<td><a href="https://github.com/minad/creole" title="Creole">Creole</a></td>
</tr>
<tr>
<td>Extensão do Arquivo</td>
<td><tt>.creole</tt></td>
</tr>
<tr>
<td>Exemplo</td>
<td><tt>creole :wiki, :layout_engine => :erb</tt></td>
</tr>
</table>
Não é possível chamar métodos por este template, nem passar *locals* para o
mesmo. Portanto normalmente é utilizado junto a outra engine de renderização:
```ruby
erb :overview, :locals => { :text => creole(:introduction) }
```
Note que você também pode chamar o método `creole` dentro de outros templates:
```ruby
%h1 Olá do Haml!
%p= creole(:saudacoes)
```
Já que você não pode chamar o Ruby pelo Creole, você não
pode utilizar um layout escrito em Creole. Contudo é
possível utilizar outra engine de renderização como template,
deve-se passar a `:layout_engine` como opção.
#### MediaWiki Templates
<table>
<tr>
<td>Dependência</td>
<td>
<a href="https://github.com/nricciar/wikicloth" title="WikiCloth">
WikiCloth
</a>
</td>
</tr>
<tr>
<td>Extensão do Arquivo</td>
<td><tt>.mediawiki</tt> and <tt>.mw</tt></td>
</tr>
<tr>
<td>Exemplo</td>
<td><tt>mediawiki :wiki, :layout_engine => :erb</tt></td>
</tr>
</table>
It is not possible to call methods from MediaWiki markup, nor to pass locals to
it. You therefore will usually use it in combination with another rendering
engine:
```ruby
erb :overview, :locals => { :text => mediawiki(:introduction) }
```
Note that you may also call the `mediawiki` method from within other templates:
```ruby
%h1 Hello From Haml!
%p= mediawiki(:greetings)
```
Já que você não pode chamar o Ruby pelo MediaWiki, você não
pode utilizar um layout escrito em MediaWiki. Contudo é
possível utilizar outra engine de renderização como template,
deve-se passar a `:layout_engine` como opção.
#### CoffeeScript Templates
<table>
<tr>
<td>Dependência</td>
<td>
<a href="https://github.com/josh/ruby-coffee-script" title="Ruby CoffeeScript">
CoffeeScript
</a> and a
<a href="https://github.com/sstephenson/execjs/blob/master/README.md#readme" title="ExecJS">
way to execute javascript
</a>
</td>
</tr>
<tr>
<td>Extensão do Arquivo</td>
<td><tt>.coffee</tt></td>
</tr>
<tr>
<td>Exemplo</td>
<td><tt>coffee :index</tt></td>
</tr>
</table>
#### Stylus Templates
<table>
<tr>
<td>Dependência</td>
<td>
<a href="https://github.com/forgecrafted/ruby-stylus" title="Ruby Stylus">
Stylus
</a> and a
<a href="https://github.com/sstephenson/execjs/blob/master/README.md#readme" title="ExecJS">
way to execute javascript
</a>
</td>
</tr>
<tr>
<td>Extensão do Arquivo</td>
<td><tt>.styl</tt></td>
</tr>
<tr>
<td>Exemplo</td>
<td><tt>stylus :index</tt></td>
</tr>
</table>
Antes que você possa utilizar o template Stylus primeiro você deve carregar
`stylus` e `stylus/tilt`:
```ruby
require 'sinatra'
require 'stylus'
require 'stylus/tilt'
get '/' do
stylus :exemplo
end
```
#### Yajl Templates
<table>
<tr>
<td>Dependência</td>
<td>
<a href="https://github.com/brianmario/yajl-ruby" title="yajl-ruby">
yajl-ruby
</a>
</td>
</tr>
<tr>
<td>Extensão do Arquivo</td>
<td><tt>.yajl</tt></td>
</tr>
<tr>
<td>Exemplo</td>
<td>
<tt>
yajl :index,
:locals => { :key => 'qux' },
:callback => 'present',
:variable => 'resource'
</tt>
</td>
</tr>
</table>
O código-fonte do template é executado como uma string Ruby e a variável
resultante em json é convertida utilizando `#to_json`:
```ruby
json = { :foo => 'bar' }
json[:baz] = key
```
O `:callback` e `:variable` são opções que podem ser utilizadas para o objeto
de renderização:
```javascript
var resource = {"foo":"bar","baz":"qux"};
present(resource);
```
#### WLang Templates
<table>
<tr>
<td>Dependência</td>
<td>
<a href="https://github.com/blambeau/wlang/" title="WLang">WLang</a>
</td>
</tr>
<tr>
<td>Extensão do Arquivo</td>
<td><tt>.wlang</tt></td>
</tr>
<tr>
<td>Exemplo</td>
<td><tt>wlang :index, :locals => { :key => 'value' }</tt></td>
</tr>
</table>
Já que você não pode chamar o Ruby (exceto pelo método
`yield`) pelo template WLang,
você quase sempre precisará passar o `locals` para ele.
## Acessando Variáveis nos Templates
Templates são avaliados dentro do mesmo contexto como manipuladores de
rota. Variáveis de instância definidas em manipuladores de rota são
diretamente acessadas por templates:
```ruby
get '/:id' do
@foo = Foo.find(params['id'])
haml '%h1= @foo.nome'
end
```
Ou, especifique um hash explícito de variáveis locais:
```ruby
get '/:id' do
foo = Foo.find(params['id'])
haml '%h1= foo.nome', :locals => { :foo => foo }
end
```
Isso é tipicamente utilizando quando renderizamos templates como
partials dentro de outros templates.
### Templates com `yield` e layouts aninhados
Um layout geralmente é apenas um template que executa `yield`.
Tal template pode ser utilizado pela opção `:template` descrita acima ou pode
ser renderizado através de um bloco, como a seguir:
```ruby
erb :post, :layout => false do
erb :index
end
```
Este código é quase equivalente a `erb :index, :layout => :post`
Passando blocos para os métodos de renderização é útil para criar layouts
aninhados:
```ruby
erb :main_layout, :layout => false do
erb :admin_layout do
erb :user
end
end
```
Também pode ser feito com menos linhas de código:
```ruby
erb :admin_layout, :layout => :main_layout do
erb :user
end
```
Atualmente os métodos listados aceitam blocos: `erb`, `haml`,
`liquid`, `slim `, `wlang`. E o método geral `render` também aceita blocos.
### Templates Inline
Templates podem ser definidos no final do arquivo fonte:
```ruby
require 'sinatra'
get '/' do
haml :index
end
__END__
@@ layout
%html
= yield
@@ index
%div.title Olá Mundo.
```
NOTA: Templates inline definidos no arquivo fonte são automaticamente
carregados pelo Sinatra. Digite `enable :inline_templates` explicitamente se
você tem templates inline em outros arquivos fonte.
### Templates Nomeados
Templates também podem ser definidos utilizando o método top-level
`template`:
```ruby
template :layout do
"%html\n =yield\n"
end
template :index do
'%div.title Olá Mundo!'
end
get '/' do
haml :index
end
```
Se existir um template com nome “layout”, ele será utilizado toda vez
que um template for renderizado. Você pode desabilitar layouts passando
`:layout => false` ou desabilita-los por padrão
via `set :haml, :layout => false`
```ruby
get '/' do
haml :index, :layout => !request.xhr?
end
```
### Associando Extensões de Arquivos
Para associar uma extensão de arquivo com um engine de template use o método
`Tilt.register`. Por exemplo, se você quiser usar a extensão `tt` para os
templates Textile você pode fazer o seguinte:
```ruby
Tilt.register :tt, Tilt[:textile]
```
### Adicionando seu Próprio Engine de Template
Primeiro registre seu engine utilizando o Tilt, e então crie um método de
renderização:
```ruby
Tilt.register :myat, MyAwesomeTemplateEngine
helpers do
def myat(*args) render(:myat, *args) end
end
get '/' do
myat :index
end
```
Renderize `./views/index.myat`. Aprenda mais sobre o
Tilt [aqui](https://github.com/rtomayko/tilt#readme).
### Customizando Lógica para Encontrar Templates
Para implementar sua própria lógica para busca de templates você pode escrever
seu próprio método `#find_template`
```ruby
configure do
set :views [ './views/a', './views/b' ]
end
def find_template(views, name, engine, &block)
Array(views).each do |v|
super(v, name, engine, &block)
end
end
```
## Filtros
Filtros Before são avaliados antes de cada requisição dentro do contexto
da requisição e podem modificar a requisição e a reposta. Variáveis de
instância definidas nos filtros são acessadas através de rotas e
templates:
```ruby
before do
@nota = 'Oi!'
request.path_info = '/foo/bar/baz'
end
get '/foo/*' do
@nota #=> 'Oi!'
params['splat'] #=> 'bar/baz'
end
```
Filtros After são avaliados após cada requisição dentro do mesmo contexto da
requisição e também podem modificar a requisição e a resposta. Variáveis de
instância definidas nos filtros before e rotas são acessadas através dos
filtros after:
```ruby
after do
puts response.status
end
```
Nota: A não ser que você use o método `body` ao invés de apenas retornar uma
String das rotas, o corpo ainda não estará disponível no filtro after, uma vez
que é gerado depois.
Filtros opcionalmente têm um padrão, fazendo com que sejam avaliados
somente se o caminho do pedido coincidir com esse padrão:
```ruby
before '/protected/*' do
authenticate!
end
after '/create/:slug' do |slug|
session[:last_slug] = slug
end
```
Como rotas, filtros também aceitam condições:
```ruby
before :agent => /Songbird/ do
#...
end
after '/blog/*', :host_name => 'exemplo.com' do
#...
end
```
## Helpers
Use o método de alto nível `helpers` para definir métodos auxiliares
para utilizar em manipuladores de rotas e modelos:
```ruby
helpers do
def bar(nome)
"#{nome}bar"
end
end
get '/:nome' do
bar(params['nome'])
end
```
Alternativamente, métodos auxiliares podem ser definidos separadamente em
módulos:
```ruby
module FooUtils
def foo(nome) "#{nome}foo" end
end
module BarUtils
def bar(nome) "#{nome}bar" end
end
helpers FooUtils, BarUtils
```
O efeito é o mesmo que incluir os módulos na classe da aplicação.
### Utilizando Sessões
Uma sessão é usada para manter o estado durante requisições. Se ativada, você
terá disponível um hash de sessão para cada sessão de usuário:
```ruby
enable :sessions
get '/' do
"value = " << session[:value].inspect
end
get '/:value' do
session['value'] = params['value']
end
```
#### Segredo Seguro da Sessão
Para melhorar a segurança, os dados da sessão no cookie são assinado com uma
segredo de sessão usando `HMAC-SHA1`. Esse segredo de sessão deve ser, de
preferência, um valor criptograficamente randômico, seguro, de um comprimento
apropriado no qual `HMAC-SHA1` é maior ou igual a 64 bytes (512 bits, 128
caracteres hexadecimais). Você será avisado para não usar uma chave secreta
menor que 32 bytes de randomicidade (256 bits, 64 caracteres hexadecimais).
Portanto, é **muito importante** que você não invente o segredo, mas use um
gerador de números aleatórios seguro para cria-lo. Humanos são extremamente
ruins em gerar números aleatórios.
Por padrão, um segredo de sessão aleatório seguro de 32 bytes é gerada para
você pelo Sinatra, mas ele mudará toda vez que você reiniciar sua aplicação. Se
você tiver múltiplas instâncias da sua aplicação e você deixar que o Sinatra
gere a chave, cada instância teria uma chave de sessão diferente, o que
certamente não é o que você quer.
Para melhor segurança e usabilidade é
[recomendado](https://12factor.net/config) que você gere um segredo randômico
secreto e salve-o em uma variável de ambiente em cada host rodando sua
aplicação, assim todas as instâncias da sua aplicação irão compartilhar o mesmo
segredo. Você deve, periodicamente, mudar esse segredo de sessão para um novo
valor. Abaixo, são mostrados alguns exemplos de como você pode criar um segredo
de 64 bytes e usa-lo:
**Gerando Segredo de Sessão**
```text
$ ruby -e "require 'securerandom'; puts SecureRandom.hex(64)"
99ae8af...snip...ec0f262ac
```
**Gerando Segredo de Sessão (Pontos adicionais)**
Use preferencialmente a
[gem sysrandom](https://github.com/cryptosphere/sysrandom#readme) para utilizar
as facilidades do sistema RNG para gerar valores aleatórios ao invés
do `OpenSSL` no qual o MRI Ruby padroniza para:
```text
$ gem install sysrandom
Building native extensions. This could take a while...
Sucessfully installed sysrandom-1.x
1 gem installed
$ ruby -e "require 'sysrandom/securerandom'; puts SecureRandom.hex(64)"
99ae8af...snip...ec0f262ac
```
**Segredo de Sessão numa Variável de Ambiente**
Defina uma variável de ambiente `SESSION_SECRET` para o Sinatra com o valor que
você gerou. Salve esse valor entre as reinicializações do seu host. Já que a
forma de fazer isso irá variar entre os sistemas operacionais, o exemplo abaixo
serve apenas para fins ilustrativos:
```bash
# echo "export SESSION_SECRET = 99ae8af...snip...ec0f262ac" >> ~/.bashrc
```
**Configurando o Segredo de Sessão na Aplicação**
Configure sua aplicação para uma falha de segredo seguro aleatório se a
variável de ambiente `SESSION_SECRET` não estiver disponível.
Como ponto adicional use a
[gem sysrandom](https://github.com/cryptosphere/sysrandom#readme) da seguinte
forma:
```ruby
require 'securerandom'
# -or- require 'sysrandom/securearandom'
set :session_secret, ENV.fecth(`SESSION_SECRET`) { SecureRandom.hex(64) }
```
#### Configuração de Sessão
Se você deseja configurar isso adicionalmente, você pode salvar um hash com
opções na definição de `sessions`:
```ruby
set :sessions, :domain => 'foo.com'
```
Para compartilhar sua sessão com outras aplicações no subdomínio de foo.com,
adicione um *.* antes do domínio como no exemplo abaixo:
```ruby
set :sessions, :domain => '.foo.com'
```
#### Escolhendo Seu Próprio Middleware de Sessão
Perceba que `enable :sessions` na verdade guarda todos seus dados num cookie.
Isto pode não ser o que você deseja sempre (armazenar muitos dados irá aumentar
seu tráfego, por exemplo). Você pode usar qualquer middleware de sessão Rack
para fazer isso, um dos seguintes métodos pode ser usado:
```ruby
enable :sessions
set :session_store, Rack::Session::Pool
```
Ou definir as sessões com um hash de opções:
```ruby
set :sessions, :expire_after => 2592000
set :session_store, Rack::Session::Pool
```
Outra opção é **não** usar `enable :sessions`, mas ao invés disso trazer seu
middleware escolhido como você faria com qualquer outro middleware.
É importante lembrar que usando esse método, a proteção baseada na sessão
**não estará habilitada por padrão**.
Para o middleware Rack fazer isso, será preciso que isso também seja adicionado:
```ruby
use Rack::Session::Pool, :expire_after => 2592000
use Rack::Protection::RemoteToken
use Rack::Protection::SessionHijacking
```
Veja '[Configurando proteção a ataques](#configurando-proteção-a-ataques)' para
mais informações.
### Parando
Para parar imediatamente uma requisição com um filtro ou rota utilize:
```ruby
halt
```
Você também pode especificar o status quando parar:
```ruby
halt 410
```
Ou o corpo:
```ruby
halt 'isso será o corpo'
```
Ou ambos:
```ruby
halt 401, 'vá embora!'
```
Com cabeçalhos:
```ruby
halt 402, {'Content-Type' => 'text/plain'}, 'revanche'
```
Também é obviamente possível combinar um template com o `halt`:
```ruby
halt erb(:error)
```
### Passing
Uma rota pode processar aposta para a próxima rota correspondente usando
`pass`:
```ruby
get '/adivinhar/:quem' do
pass unless params['quem'] == 'Frank'
'Você me pegou!'
end
get '/adivinhar/*' do
'Você falhou!'
end
```
O bloqueio da rota é imediatamente encerrado e o controle continua com a
próxima rota compatível. Se nenhuma rota compatível for encontrada, um
404 é retornado.
### Desencadeando Outra Rota
As vezes o `pass` não é o que você quer, ao invés dele talvez você queira obter
o resultado chamando outra rota. Simplesmente utilize o método `call` neste
caso:
```ruby
get '/foo' do
status, headers, body = call env.merge("PATH_INFO" => '/bar')
[status, headers, body.map(&:upcase)]
end
get '/bar' do
"bar"
end
```
Note que no exemplo acima você ganharia performance e facilitaria os testes ao
simplesmente mover `"bar"` para um método auxiliar usado por ambos `/foo`
e `/bar`.
Se você quer que a requisição seja enviada para a mesma instância da aplicação
no lugar de uma duplicada, use `call!` no lugar de `call`.
Veja a especificação do Rack se você quer aprender mais sobre o `call`.
### Definindo Corpo, Código de Status e Cabeçalhos
É possível e recomendado definir o código de status e o corpo da resposta com o
valor retornado do bloco da rota. Entretanto, em alguns cenários você pode
querer definir o corpo em um ponto arbitrário do fluxo de execução. Você pode
fazer isso com o método auxiliar `body`. Se você fizer isso, poderá usar esse
método de agora em diante para acessar o body:
```ruby
get '/foo' do
body "bar"
end
after do
puts body
end
```
Também é possível passar um bloco para `body`, que será executado pelo
manipulador Rack (isso pode ser usado para implementar transmissão,
[veja "Retorno de Valores"](#retorno-de-valores)).
Similar ao corpo, você pode também definir o código de status e cabeçalhos:
```ruby
get '/foo' do
status 418
headers \
"Allow" => "BREW, POST, GET, PROPFIND, WHEN"
"Refresh" => "Refresh: 20; https://ietf.org/rfc/rfc2324.txt"
body "Eu sou um bule de chá!"
end
```
Assim como `body`, `headers` e `status` sem argumentos podem ser usados para
acessar seus valores atuais.
### Transmitindo Respostas
As vezes você quer começar a mandar dados enquanto está gerando partes do corpo
da resposta. Em exemplos extremos, você quer continuar enviando dados até o
cliente encerrar a conexão. Você pode usar o método auxiliar `stream` para
evitar criar seu próprio empacotador:
```ruby
get '/' do
stream do |out|
out << "Isso será len -\n"
sleep 0.5
out << " Aguarde \n"
sleep 1
out << " dário!\n"
end
end
```
Isso permite você implementar APIs de Transmissão,
[Eventos Enviados pelo Servidor](https://w3c.github.io/eventsource/), e pode
ser usado como a base para
[WebSockets](https://en.wikipedia.org/wiki/WebSocket). Pode ser usado também
para aumentar a taxa de transferência se algum, mas não todo, conteúdo depender
de um recurso lento.
Perceba que o comportamento da transmissão, especialmente o número de
requisições concorrentes, depende altamente do servidor web usado para servir a
aplicação. Alguns servidores podem até mesmo não suportar transmissão de
maneira alguma. Se o servidor não suportar transmissão, o corpo será enviado
completamente após que o bloco passado para `stream` terminar de executar.
Transmissão não funciona de nenhuma maneira com Shotun.
Se o parâmetro opcional é definido como `keep_open`, ele não chamará `close` no
objeto transmitido, permitindo você a fecha-lo em algum outro ponto futuro no
fluxo de execução. Isso funciona apenas em servidores orientados a eventos,
como Thin e Rainbows. Outros servidores irão continuar fechando a transmissão:
```ruby
# long polling
set :server, :thin
conexoes = []
get '/assinar' do
# registra o interesse de um cliente em servidores de eventos
stream(:keep_open) do |saida|
conexoes << saida
# retire conexões mortas
conexoes.reject!(&:closed?)
end
end
post '/:mensagem' do
conexoes.each do |saida|
# notifica o cliente que uma nova mensagem chegou
saida << params['mensagem'] << "\n"
# indica ao cliente para se conectar novamente
saida.close
end
# confirma
"mensagem recebida"
end
```
Também é possível para o cliente fechar a conexão quando está tentando escrever
para o socket. Devido a isso, é recomendado checar `out.closed?` antes de
tentar escrever.
### Usando Logs
No escopo da requisição, o método auxiliar `logger` expõe uma instância
`Logger`:
```ruby
get '/' do
logger.info "loading data"
# ...
end
```
Esse logger irá automaticamente botar as configurações de log do manipulador
Rack na sua conta. Se a produção de logs estiver desabilitada, esse método
retornará um objeto dummy, então você não terá que se preocupar com suas rotas
e filtros.
Perceba que a produção de logs está habilitada apenas para
`Sinatra::Application` por padrão, então se você herdar de `Sinatra::Base`,
você provavelmente irá querer habilitar:
```ruby
class MyApp < Sinatra::Base
configure :production, :development do
enable :logging
end
end
```
Para evitar que qualquer middleware de logs seja configurado, defina a
configuração `logging` como `nil`. Entretanto, tenha em mente que `logger`
retornará, nesse caso, `nil`. Um caso de uso comum é quando você quer definir
seu próprio logger. Sinatra irá usar qualquer um que ele achar
em `env['rack.logger']`
### Tipos Mime
Quando se está usando `send_file` ou arquivos estáticos, você pode ter tipos
mime que o Sinatra não entende. Use `mime_type` para registrá-los pela extensão
do arquivo:
```ruby
configure do
mime_type :foo, 'text/foo'
end
```
Você pode utilizar também com o método auxiliar `content_type`:
```ruby
get '/' do
content-type :foo
"foo foo foo"
end
```
### Gerando URLs
Para gerar URLs você deve usar o método auxiliar `url` no Haml:
```ruby
%a{:href => url('/foo')} foo
```
Isso inclui proxies reversos e rotas Rack, se presentes.
Esse método é também apelidado para `to` (veja
[abaixo](#redirecionamento-do-browser) para um exemplo).
### Redirecionamento do Browser
Você pode lançar um redirecionamento no browser com o método auxiliar
`redirect`:
```ruby
get '/foo' do
redirect to('/bar')
end
```
Quaisquer parâmetros adicionais são interpretados como argumentos passados
ao `halt`:
```ruby
redirect to('/bar'), 303
redirect 'http://www.google.com/', 'lugar errado, amigo'
```
Você pode também facilmente redirecionar para a página da qual o usuário veio
com `redirect back`:
```ruby
get '/foo' do
"<a href='/bar'>do something</a>"
end
get '/bar' do
do_something
redirect back
end
```
Para passar argumentos com um redirecionamento, adicione-os a query:
```ruby
redirect to('/bar?sum=42')
```
Ou use uma sessão:
```ruby
enable :sessions
get '/foo' do
session[:secret] = 'foo'
redirect to('/bar')
end
get '/bar' do
session[:secret]
end
```
### Controle de Cache
Definir sues cabeçalhos corretamente é o principal passo para uma correta cache
HTTP.
Você pode facilmente definir o cabeçalho de Cache-Control como:
```ruby
get '/' do
cache_control :public
"guarde isso!"
end
```
Dica profissional: Configure a cache em um filtro anterior:
```ruby
before do
cache_control :public, :must_revalidate, :max_age => 60
end
```
Se você está usando o método auxiliar `expires` para definir seu cabeçalho
correspondente, `Cache-Control` irá ser definida automaticamente para você:
```ruby
before do
expires 500, :public, :must_revalidate
end
```
Para usar propriciamente caches, você deve considerar usar `etag` ou
`last_modified`. É recomendado chamar esses métodos auxiliares *antes* de fazer
qualquer tipo de processamento pesado, já que eles irão imediatamente retornar
uma resposta se o cliente já possui a versão atual na sua cache:
```ruby
get "/artigo/:id" do
@artigo = Artigo.find params['id']
last_modified @artigo.updated_at
etag @artigo.sha1
erb :artigo
end
```
Também é possível usar uma
[ETag fraca](https://en.wikipedia.org/wiki/HTTP_ETag#Strong_and_weak_validation):
```ruby
etag @article.sha1, :weak
```
Esses métodos auxiliares não irão fazer nenhum processo de cache para você, mas
irão alimentar as informações necessárias para sua cache. Se você está
pesquisando por uma solução rápida de fazer cache com proxy-reverso, tente
[rack-cache](https://github.com/rtomayko/rack-cache#readme):
```ruby
require "rack/cache"
require "sinatra"
use Rack::Cache
get '/' do
cache_control :public, :max_age => 36000
sleep 5
"olá"
end
```
Use a configuração `:static_cache_control` (veja [acima]#(controle-de-cache))
para adicionar o cabeçalho de informação `Cache-Control` para arquivos
estáticos.
De acordo com a RFC 2616, sua aplicação deve se comportar diferentemente se o
cabeçalho If-Match ou If-None-Match é definido para `*`, dependendo se o
recurso requisitado já existe. Sinatra assume que recursos para requisições
seguras (como get) e idempotentes (como put) já existem, enquanto que para
outros recursos (por exemplo requisições post) são tratados como novos
recursos. Você pode mudar esse comportamento passando em uma opção
`:new_resource`:
```ruby
get '/create' do
etag '', :new_resource => true
Artigo.create
erb :novo_artigo
end
```
Se você quer continuar usando um ETag fraco, passe em uma opção `:kind`:
```ruby
etag '', :new_resource => true, :kind => :weak
```
### Enviando Arquivos
Para retornar os conteúdos de um arquivo como as resposta, você pode usar o
método auxiliar `send_file`:
```ruby
get '/' do
send_file 'foo.png'
end
```
Também aceita opções:
```ruby
send_file 'foo.png', :type => :jpg
```
As opções são:
<dl>
<dt>filename</dt>
<dd>Nome do arquivo a ser usado na respota,
o padrão é o nome do arquivo reak</dd>
<dt>last_modified</dt>
<dd>Valor do cabeçalho Last-Modified, o padrão corresponde ao mtime do
arquivo.</dd>
<dt>type</dt>
<dd>Valor do cabeçalho Content-Type, extraído da extensão do arquivo se
inexistente.</dd>
<dt>disposition</dt>
<dd>
Valor do cabeçalho Content-Disposition, valores possíveis: <tt>nil</tt>
(default), <tt>:attachment</tt> and <tt>:inline</tt>
</dd>
<dt>length</dt>
<dd>Valor do cabeçalho Content-Length, o padrão corresponde ao tamanho do
arquivo.</dd>
<dt>status</dt>
<dd>
Código de status a ser enviado. Útil quando está se enviando um arquivo
estático como uma página de erro. Se suportado pelo handler do Rack,
outros meios além de transmissão do processo do Ruby serão usados.
So você usar esse método auxiliar, o Sinatra irá automaticamente lidar com
requisições de alcance.
</dd>
</dl>
### Acessando o Objeto da Requisição
O objeto vindo da requisição pode ser acessado do nível de requisição (filtros,
rotas, manipuladores de erro) através do método `request`:
```ruby
# app rodando em http://exemplo.com/exemplo
get '/foo' do
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 # corpo da requisição enviado pelo cliente (veja abaixo)
request.scheme # "http"
request.script_name # "/exemplo"
request.path_info # "/foo"
request.port # 80
request.request_method # "GET"
request.query_string # ""
request.content_length # tamanho do request.body
request.media_type # tipo de mídia of request.body
request.host # "exemplo.com"
request.get? # true (método similar para outros tipos de requisição)
request.form_data? # false
request["algum_ param"] # valor do parâmetro 'algum_param'. [] é um atalho para o hash de parâmetros
request.referrer # a referência do cliente ou '/'
request.user_agent # agente de usuário (usado por :agent condition)
request.cookies # hash dos cookies do browser
request.xhr? # isto é uma requisição ajax?
request.url # "http://exemplo.com/exemplo/foo"
request.path # "/exemplo/foo"
request.ip # endereço de IP do cliente
request.secure? # false (seria true se a conexão fosse ssl)
request.forwarded? # true (se está rodando por um proxy reverso)
request.env # raw env hash handed in by Rack
end
```
Algumas opções, como `script_name` ou `path_info, podem ser escritas como:
```ruby
before { request.path_info = "/" }
get "/" do
"todas requisições acabam aqui"
end
```
`request.body` é uma ES ou um objeto StringIO:
```ruby
post "/api" do
request.body.rewind # em caso de algo já ter lido
data = JSON.parse request.body.read
"Oi #{data['nome']}!"
end
```
### Anexos
Você pode usar o método auxiliar `attachment` para dizer ao navegador que a
resposta deve ser armazenada no disco no lugar de ser exibida no browser:
```ruby
get '/' do
attachment "info.txt"
"salve isso!"
end
```
### Trabalhando com Data e Hora
O Sinatra oferece um método auxiliar `time_for` que gera um objeto Time do
valor dado. É também possível converter `DateTime`, `Date` e classes similares:
```ruby
get '/' do
pass if Time.now > time_for('Dec 23, 2016')
"continua no tempo"
end
```
Esse método é usado internamente por `expires`, `last_modified` e akin. Você
pode portanto facilmente estender o comportamento desses métodos sobrescrevendo
`time_for` na sua aplicação:
```ruby
helpers do
def time_for(valor)
case valor
when :ontem then Time.now - 24*60*60
when :amanha then Time.now + 24*60*60
else super
end
end
end
get '/' do
last_modified :ontem
expires :amanha
"oi"
end
```
### Pesquisando por Arquivos de Template
O método auxiliar `find_template` é usado para encontrar arquivos de template
para renderizar:
```ruby
find_template settings.views, 'foo', Tilt[:haml] do |arquivo|
puts "pode ser #{arquivo}"
end
```
Isso não é realmente útil. Mas é útil que você possa na verdade sobrescrever
esse método para conectar no seu próprio mecanismo de pesquisa. Por exemplo, se
você quer ser capaz de usar mais de um diretório de view:
```ruby
set :views, ['views', 'templates']
helpers do
def find_template(views, name, engine, &block)
Array(views).each { |v| super(v, name, engine, &block) }
end
end
```
Outro exemplo seria utilizando diretórios diferentes para motores (engines)
diferentes:
```ruby
set :views, :sass => 'views/sass', :haml => 'templates', :default => 'views'
helpers do
def find_template(views, name, engine, &block)
_, folder = views.detect { |k,v| engine == Tilt[k] }
folder ||= views[:default]
super(folder, name, engine, &block)
end
end
```
Você pode facilmente embrulhar isso é uma extensão e compartilhar com outras
pessoas!
Perceba que `find_template` não verifica se o arquivo realmente existe. Ao
invés disso, ele chama o bloco dado para todos os caminhos possíveis. Isso não
significa um problema de perfomance, já que `render` irá usar `break` assim que
o arquivo é encontrado. Além disso, as localizações (e conteúdo) de templates
serão guardados na cache se você não estiver rodando no modo de
desenvolvimento. Você deve se lembrar disso se você escrever um método
realmente maluco.
## Configuração
É possível e recomendado definir o código de status e o corpo da resposta com o
valor retornado do bloco da rota. Entretanto, em alguns cenários você pode
querer definir o corpo em um ponto arbitrário do fluxo de execução. Você pode
fazer isso com o método auxiliar `body`. Se você fizer isso, poderá usar esse
método de agora em diante para acessar o body:
```ruby
get '/foo' do
body "bar"
end
after do
puts body
end
```
Também é possível passar um bloco para `body`, que será executado pelo
manipulador Rack (isso pode ser usado para implementar transmissão,
[veja "Retorno de Valores"](#retorno-de-valores)).
Similar ao corpo, você pode também definir o código de status e cabeçalhos:
```ruby
get '/foo' do
status 418
headers \
"Allow" => "BREW, POST, GET, PROPFIND, WHEN"
"Refresh" => "Refresh: 20; https://ietf.org/rfc/rfc2324.txt"
body "Eu sou um bule de chá!"
end
```
Assim como `body`, `headers` e `status` sem argumentos podem ser usados para
acessar seus valores atuais.
### Transmitindo Respostas
As vezes você quer começar a mandar dados enquanto está gerando partes do corpo
da resposta. Em exemplos extremos, você quer continuar enviando dados até o
cliente encerrar a conexão. Você pode usar o método auxiliar `stream` para
evitar criar seu próprio empacotador:
```ruby
get '/' do
stream do |out|
out << "Isso será len -\n"
sleep 0.5
out << " Aguarde \n"
sleep 1
out << " dário!\n"
end
end
```
Isso permite você implementar APIs de Transmissão,
[Eventos Enviados pelo Servidor](https://w3c.github.io/eventsource/), e pode
ser usado como a base para
[WebSockets](https://en.wikipedia.org/wiki/WebSocket). Pode ser usado também
para aumentar a taxa de transferência se algum, mas não todo, conteúdo depender
de um recurso lento.
Perceba que o comportamento da transmissão, especialmente o número de
requisições concorrentes, depende altamente do servidor web usado para servir a
aplicação. Alguns servidores podem até mesmo não suportar transmissão de
maneira alguma. Se o servidor não suportar transmissão, o corpo será enviado
completamente após que o bloco passado para `stream` terminar de executar.
Transmissão não funciona de nenhuma maneira com Shotun.
Se o parâmetro opcional é definido como `keep_open`, ele não chamará `close` no
objeto transmitido, permitindo você a fecha-lo em algum outro ponto futuro no
fluxo de execução. Isso funciona apenas em servidores orientados a eventos,
como Thin e Rainbows. Outros servidores irão continuar fechando a transmissão:
```ruby
# long polling
set :server, :thin
conexoes = []
get '/assinar' do
# registra o interesse de um cliente em servidores de eventos
stream(:keep_open) do |saida|
conexoes << saida
# retire conexões mortas
conexoes.reject!(&:closed?)
end
end
post '/:messagem' do
conexoes.each do |saida|
# notifica o cliente que uma nova mensagem chegou
saida << params['messagem'] << "\n"
# indica ao cliente para se conectar novamente
saida.close
end
# confirma
"messagem recebida"
end
```
Também é possível para o cliente fechar a conexão quando está tentando escrever
para o socket. Devido a isso, é recomendado checar `out.closed?` antes de
tentar escrever.
### Usando Logs
No escopo da requisição, o método auxiliar `logger` expõe uma instância
`Logger`:
```ruby
get '/' do
logger.info "loading data"
# ...
end
```
Esse logger irá automaticamente botar as configurações de log do manipulador
Rack na sua conta. Se a produção de logs estiver desabilitada, esse método
retornará um objeto dummy, então você não terá que se preocupar com suas rotas
e filtros.
Perceba que a produção de logs está habilitada apenas para
`Sinatra::Application` por padrão, então se você herdar de `Sinatra::Base`,
você provavelmente irá querer habilitar:
```ruby
class MyApp < Sinatra::Base
configure :production, :development do
enable :logging
end
end
```
Para evitar que qualquer middleware de logs seja configurado, defina a
configuração `logging` como `nil`. Entretanto, tenha em mente que `logger`
retornará, nesse caso, `nil`. Um caso de uso comum é quando você quer definir
seu próprio logger. Sinatra irá usar qualquer um que ele achar em
`env['rack.logger']`
### Tipos Mime
Quando se está usando `send_file` ou arquivos estáticos, você pode ter tipos
Mime que o Sinatra não entende. Use `mime_type` para registrá-los pela extensão
do arquivo:
```ruby
configure do
mime_type :foo, 'text/foo'
end
```
Você pode utilizar também com o método auxiliar `content_type`:
```ruby
get '/' do
content-type :foo
"foo foo foo"
end
```
### Gerando URLs
Para gerar URLs você deve usar o método auxiliar `url` no Haml:
```ruby
%a{:href => url('/foo')} foo
```
Isso inclui proxies reversos e rotas Rack, se presentes.
Esse método é também apelidado para `to` (veja
[abaixo](#redirecionamento-do-browser) para um exemplo).
### Redirecionamento do Browser
Você pode lançar um redirecionamento no browser com o método auxiliar
`redirect`:
```ruby
get '/foo' do
redirect to('/bar')
end
```
Quaisquer parâmetros adicionais são interpretados como argumentos passados ao
`halt`:
```ruby
redirect to('/bar'), 303
redirect 'http://www.google.com/', 'lugar errado, amigo'
```
Você pode também facilmente redirecionar para a página da qual o usuário veio
com `redirect back`:
```ruby
get '/foo' do
"<a href='/bar'>do something</a>"
end
get '/bar' do
do_something
redirect back
end
```
Para passar argumentos com um redirecionamento, adicione-os a query:
```ruby
redirect to('/bar?sum=42')
```
Ou use uma sessão:
```ruby
enable :sessions
get '/foo' do
session[:secret] = 'foo'
redirect to('/bar')
end
get '/bar' do
session[:secret]
end
```
### Controle de Cache
Definir sues cabeçalhos corretamente é o principal passo para uma correta cache
HTTP.
Você pode facilmente definir o cabeçalho de Cache-Control como:
```ruby
get '/' do
cache_control :public
"guarde isso!"
end
```
Dica profissional: Configure a cache em um filtro anterior:
```ruby
before do
cache_control :public, :must_revalidate, :max_age => 60
end
```
Se você está usando o método auxiliar `expires` para definir seu cabeçalho
correspondente, `Cache-Control` irá ser definida automaticamente para você:
```ruby
before do
expires 500, :public, :must_revalidate
end
```
Para usar propriciamente caches, você deve considerar usar `etag` ou
`last_modified`. É recomendado chamar esses métodos auxiliares *antes* de fazer
qualquer tipo de processamento pesado, já que eles irão imediatamente retornar
uma resposta se o cliente já possui a versão atual na sua cache:
```ruby
get "/artigo/:id" do
@artigo = Artigo.find params['id']
last_modified @artigo.updated_at
etag @artigo.sha1
erb :artigo
end
```
Também é possível usar uma
[ETag fraca](https://en.wikipedia.org/wiki/HTTP_ETag#Strong_and_weak_validation):
```ruby
etag @article.sha1, :weak
```
Esses métodos auxiliares não irão fazer nenhum processo de cache para você, mas
irão alimentar as informações necessárias para sua cache. Se você está
pesquisando por uma solução rápida de fazer cache com proxy-reverso, tente
[rack-cache](https://github.com/rtomayko/rack-cache#readme):
```ruby
require "rack/cache"
require "sinatra"
use Rack::Cache
get '/' do
cache_control :public, :max_age => 36000
sleep 5
"olá"
end
```
Use a configuração `:static_cache_control` (veja [acima]#(controle-de-cache))
para adicionar o cabeçalho de informação `Cache-Control` para arquivos
estáticos.
De acordo com a RFC 2616, sua aplicação deve se comportar diferentemente se o
cabeçalho If-Match ou If-None-Match é definido para `*`, dependendo se o
recurso requisitado já existe. Sinatra assume que recursos para requisições
seguras (como get) e idempotentes (como put) já existem, enquanto que para
outros recursos (por exemplo requisições post) são tratados como novos
recursos. Você pode mudar esse comportamento passando em uma opção
`:new_resource`:
```ruby
get '/create' do
etag '', :new_resource => true
Artigo.create
erb :novo_artigo
end
```
Se você quer continuar usando um ETag fraco, passe em uma opção `:kind`:
```ruby
etag '', :new_resource => true, :kind => :weak
```
### Enviando Arquivos
Para retornar os conteúdos de um arquivo como as resposta, você pode usar o
método auxiliar `send_file`:
```ruby
get '/' do
send_file 'foo.png'
end
```
Também aceita opções:
```ruby
send_file 'foo.png', :type => :jpg
```
As opções são:
<dl>
<dt>filename</dt>
<dd>Nome do arquivo a ser usado na respota,
o padrão é o nome do arquivo reak</dd>
<dt>last_modified</dt>
<dd>Valor do cabeçalho Last-Modified, o padrão corresponde ao mtime do
arquivo.</dd>
<dt>type</dt>
<dd>Valor do cabeçalho Content-Type, extraído da extensão do arquivo se
inexistente.</dd>
<dt>disposition</dt>
<dd>
Valor do cabeçalho Content-Disposition, valores possíveis: <tt>nil</tt>
(default), <tt>:attachment</tt> and <tt>:inline</tt>
</dd>
<dt>length</dt>
<dd>Valor do cabeçalho Content-Length, o padrão corresponde ao tamanho do
arquivo.</dd>
<dt>status</dt>
<dd>
Código de status a ser enviado. Útil quando está se enviando um arquivo
estático como uma página de erro. Se suportado pelo handler do Rack,
outros meios além de transmissão do processo do Ruby serão usados.
So você usar esse método auxiliar, o Sinatra irá automaticamente lidar
com requisições de alcance.
</dd>
</dl>
### Acessando o Objeto da Requisção
O objeto vindo da requisição pode ser acessado do nível de requisição (filtros,
rotas, manipuladores de erro) através do método `request`:
```ruby
# app rodando em http://exemplo.com/exemplo
get '/foo' do
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 # corpo da requisição enviado pelo cliente (veja abaixo)
request.scheme # "http"
request.script_name # "/exemplo"
request.path_info # "/foo"
request.port # 80
request.request_method # "GET"
request.query_string # ""
request.content_length # tamanho do request.body
request.media_type # tipo de mídia of request.body
request.host # "exemplo.com"
request.get? # true (metodo similar para outros tipos de requisição)
request.form_data? # false
request["algum_ param"] # valor do parâmetro 'algum_param'. [] é um atalho para o hash de parâmetros
request.referrer # a referência do cliente ou '/'
request.user_agent # agente de usuário (usado por :agent condition)
request.cookies # hash dos cookies do browser
request.xhr? # isto é uma requisição ajax?
request.url # "http://exemplo.com/exemplo/foo"
request.path # "/exemplo/foo"
request.ip # endereço de IP do cliente
request.secure? # false (seria true se a conexão fosse ssl)
request.forwarded? # true (se está rodando por um proxy reverso)
request.env # raw env hash handed in by Rack
end
```
Algumas opções, como `script_name` ou `path_info, podem ser escritas como:
```ruby
before { request.path_info = "/" }
get "/" do
"todas requisições acabam aqui"
end
```
`request.body` é uma ES ou um objeto StringIO:
```ruby
post "/api" do
request.body.rewind # em caso de algo já ter lido
data = JSON.parse request.body.read
"Oi #{data['nome']}!"
end
```
### Anexos
Você pode usar o método auxiliar `attachment` para dizer ao navegador que a
reposta deve ser armazenada no disco no lugar de ser exibida no browser:
```ruby
get '/' do
attachment "info.txt"
"salve isso!"
end
```
### Trabalhando com Data e Hora
O Sinatra oferece um método auxiliar `time_for` que gera um objeto Time do
valor dado. É também possível converter `DateTime`, `Date` e classes similares:
```ruby
get '/' do
pass if Time.now > time_for('Dec 23, 2016')
"continua no tempo"
end
```
Esse método é usado internamente por `expires`, `last_modified` e akin. Você
pode portanto facilmente estender o comportamento desses métodos sobrescrevendo
`time_for` na sua aplicação:
```ruby
helpers do
def time_for(valor)
case valor
when :ontem then Time.now - 24*60*60
when :amanha then Time.now + 24*60*60
else super
end
end
end
get '/' do
last_modified :ontem
expires :amanha
"oi"
end
```
### Pesquisando por Arquivos de Template
O método auxiliar `find_template` é usado para encontrar arquivos de template
para renderizar:
```ruby
find_template settings.views, 'foo', Tilt[:haml] do |arquivo|
puts "pode ser #{arquivo}"
end
```
Isso não é realmente útil. Mas é útil que você possa na verdade sobrescrever
esse método para conectar no seu próprio mecanismo de pesquisa. Por exemplo, se
você quer ser capaz de usar mais de um diretório de view:
```ruby
set :views, ['views', 'templates']
helpers do
def find_template(views, name, engine, &block)
Array(views).each { |v| super(v, name, engine, &block) }
end
end
```
Outro exemplo seria utilizando diretórios diferentes para motores (engines)
diferentes:
```ruby
set :views, :sass => 'views/sass', :haml => 'templates', :default => 'views'
helpers do
def find_template(views, name, engine, &block)
_, folder = views.detect { |k,v| engine == Tilt[k] }
folder ||= views[:default]
super(folder, name, engine, &block)
end
end
```
Você pode facilmente embrulhar isso é uma extensão e compartilhar com outras
pessoas!
Perceba que `find_template` não verifica se o arquivo realmente existe. Ao
invés disso, ele chama o bloco dado para todos os caminhos possíveis. Isso não
significa um problema de perfomance, já que `render` irá usar `break` assim que
o arquivo é encontrado. Além disso, as localizações (e conteúdo) de templates
serão guardados na cache se você não estiver rodando no modo de
desenvolvimento. Você deve se lembrar disso se você escrever um método
realmente maluco.
## Configuração
Rode uma vez, na inicialização, em qualquer ambiente:
```ruby
configure do
...
end
```
```ruby
configure do
# configurando uma opção
set :option, 'value'
# configurando múltiplas opções
set :a => 1, :b => 2
# o mesmo que `set :option, true`
enable :option
# o mesmo que `set :option, false`
disable :option
# você pode também ter configurações dinâmicas com blocos
set(:css_dir) { File.join(views, 'css') }
end
```
Rode somente quando o ambiente (`APP_ENV` variável de ambiente) é definida para
`:production`:
```ruby
configure :production do
...
end
```
Rode quando o ambiente é definido para `:production` ou `:test`:
```ruby
configure :production, :test do
...
end
```
Você pode acessar essas opções por meio de `settings`:
```ruby
configure do
set :foo, 'bar'
end
get '/' do
settings.foo? # => true
settings.foo # => 'bar'
...
end
```
### Configurando proteção a ataques
O Sinatra está usando
[Rack::Protection](https://github.com/sinatra/sinatra/tree/master/rack-protection#readme)
para defender sua aplicação contra ataques oportunistas comuns. Você pode
facilmente desabilitar esse comportamento (o que irá abrir sua aplicação à
toneladas de vulnerabilidades comuns):
```ruby
disable :protection
```
Para pular uma única camada de defesa, defina `protection` como um hash de
opções:
```ruby
set :protection, :except => :path_traversal
```
Você também pode definir em um array, visando desabilitar uma lista de
proteções:
```ruby
set :protection, :except => [:path_traversal, :session_hijacking]
```
Por padrão, o Sinatra irá configurar apenas sessões com proteção se `:sessions`
tiver sido habilitado. Veja '[Utilizando Sessões](#utilizando-sessões)'. As
vezes você pode querer configurar sessões "fora" da aplicação do Sinatra, como
em config.ru ou com uma instância de `Rack::Builder` separada. Nesse caso, você
pode continuar configurando uma sessão com proteção passando a opção `:session`:
```ruby
set :protection, :session => true
```
### Configurações Disponíveis
<dl>
<dt>absolute_redirects</dt>
<dd>
Se desabilitada, o Sinatra irá permitir redirecionamentos relativos,
entretanto, isso não estará conforme a RFC 2616 (HTTP 1.1), que permite
apenas redirecionamentos absolutos.
</dd>
<dd>
Habilite se sua aplicação estiver rodando antes de um proxy reverso que
não foi configurado corretamente. Note que o método auxiliar <tt>url</tt>
irá continuar produzindo URLs absolutas, a não ser que você passe
<tt>false</tt> como segundo parâmetro.
</dd>
<dd>Desabilitado por padrão.</dd>
<dt>add_charset</dt>
<dd>
Para tipos Mime o método auxiliar <tt>content_type</tt> irá
automaticamente adicionar a informação de codificação. Você deve adicionar
isto no lugar de sobrescrever essa opção:
<tt>settings.add_charset << "application/foobar"</tt>
</dd>
<dt>app_file</dt>
<dd>
Caminho para o arquivo principal da aplicação, usado para detectar a raíz
do projeto, views e pastas públicas e templates inline.
</dd>
<dt>bind</dt>
<dd>
Endereço IP a ser ligado (padrão: <tt>0.0.0.0</tt> ou <tt>localhost</tt>
se seu ambiente está definido como desenvolvimento). Usado apenas para
servidor embutido.
</dd>
<dt>default_encoding</dt>
<dd>Codificação assumida caso a mesma seja desconhecida (padrão corresponde
a <tt>"utf-8"</tt>).</dd>
<dt>dump_errors</dt>
<dd>Exibe erros no log.</dd>
<dt>environment</dt>
<dd>
Ambiente atual. O padrão é <tt>ENV['APP_ENV']</tt>, ou
<tt>"development"</tt> se o primeiro não estiver disponível.
</dd>
<dt>logging</dt>
<dd>Usa o logger.</dd>
<dt>lock</dt>
<dd>
Coloca um bloqueio em torno de cada requisição, executando apenas
processamento sob requisição por processo Ruby simultaneamente.
</dd>
<dd>Habilitado se sua aplicação não for 'thread-safe'. Desabilitado por
padrão.</dd>
<dt>method_override</dt>
<dd>
Use a mágica <tt>_method</tt> para permitir formulários put/delete em
navegadores que não oferecem suporte à essas operações.
</dd>
<dt>mustermann_opts</dt>
<dd>
Um hash de opções padrão para passar a Mustermann.new quando se está
compilado os caminho de roteamento.
</dd>
<dt>port</dt>
<dd>Porta a ser escutada. Usado apenas para servidores embutidos.</dd>
<dt>prefixed_redirects</dt>
<dd>
Inserir ou não inserir <tt>request.script_name</tt> nos redirecionamentos
se nenhum caminho absoluto for dado. Dessa forma <tt>redirect '/foo'</tt>
irá se comportar como <tt>redirect to('/foo').</tt>
</dd>
<dd>Desabilitado por padrão.</dd>
<dt>protection</dt>
<dd>
Habilitar ou não proteções a ataques web. Veja a sessão de proteção acima.
</dd>
<dt>public_dir</dt>
<dd>Apelido para <tt>public_folder</tt>. Veja abaixo.</dd>
<dt>public_folder</dt>
<dd>
Caminho para o diretório de arquivos públicos. Usado apenas se a exibição
de arquivos estáticos estiver habilitada (veja a configuração
<tt>static</tt> abaixo). Deduzido da configuração <tt>app_file</tt> se
não for definido.
</dd>
<dt>quiet</dt>
<dd>
Desabilita logs gerados pelos comandos de inicio e parada do Sinatra.
<tt>false</tt> por padrão.
</dd>
<dt>reload_templates</dt>
<dd>
Se deve ou não recarregar templates entre as requisições. Habilitado no
modo de desenvolvimento.
</dd>
<dt>root</dt>
<dd>
Caminho para o diretório raíz do projeto. Deduzido da configuração
<tt>app_file</tt> se não for definido.
</dd>
<dt>raise_errors</dt>
<dd>
Lança exceções (irá para a aplicação). Habilitado por padrão quando o
ambiente está definido para <tt>"test</tt>, desabilitado em caso
contrário.
</dd>
<dt>run</dt>
<dd>
Se habilitado, o Sinatra irá lidar com o início do servidor web. Não
habilite se estiver usando rackup ou outros meios.
</dd>
<dt>running</dt>
<dd>É o servidor embutido que está rodando agora? Não mude essa
configuração!</dd>
<dt>server</dt>
<dd>
Servidor ou listas de servidores para usar o servidor embutido. A ordem
indica prioridade, por padrão depende da implementação do Ruby
</dd>
<dt>server_settings</dt>
<dd>
Se você estiver usando um servidor web WEBrick, presumidamente para seu
ambiente de desenvolvimento, você pode passar um hash de opções para
<tt>server_settings</tt>, tais como <tt>SSLEnable</tt> ou
<tt>SSLVerifyClient</tt>. Entretanto, servidores web como Puma e Thin não
suportam isso, então você pode definir <tt>server_settings</tt> como um
método quando chamar <tt>configure</tt>.
</dd>
<dt>sessions</dt>
<dd>
Habilita o suporte a sessões baseadas em cookie usando
<tt>Rack::Session::Cookie</tt>. Veja a seção 'Usando Sessões' para mais
informações.
</dd>
<dt>session_store</dt>
<dd>
O middleware de sessão Rack usado. O padrão é
<tt>Rack::Session::Cookie</tt>. Veja a sessão 'Usando Sessões' para mais
informações.
</dd>
<dt>show_exceptions</dt>
<dd>
Mostra um relatório de erros no navegador quando uma exceção ocorrer.
Habilitado por padrão quando o <tt>ambiente</tt> é definido como
<tt>"development"</tt>, desabilitado caso contrário.
</dd>
<dd>
Pode também ser definido para <tt>:after_handler</tt> para disparar um
manipulador de erro específico da aplicação antes de mostrar um relatório
de erros no navagador.
</dd>
<dt>static</dt>
<dd>
Define se o Sinatra deve lidar com o oferecimento de arquivos
estáticos.
</dd>
<dd>
Desabilitado quando está utilizando um servidor capaz de fazer isso
sozinho.
</dd>
<dd>Desabilitar irá aumentar a perfomance</dd>
<dd>
Habilitado por padrão no estilo clássico, desabilitado para aplicações
modulares.
</dd>
<dt>static_cache_control</dt>
<dd>
Quando o Sinatra está oferecendo arquivos estáticos, definir isso irá
adicionar cabeçalhos <tt>Cache-Control</tt> nas respostas. Usa o método
auxiliar <tt>cache-control</tt>. Desabilitado por padrão.
</dd>
<dd>
Use um array explícito quando estiver definindo múltiplos valores:
<tt>set :static_cache_control, [:public, :max_age => 300]</tt>
</dd>
<dt>threaded</dt>
<dd>
Se estiver definido como <tt>true</tt>, irá definir que o Thin use
<tt>EventMachine.defer</tt> para processar a requisição.
</dd>
<dt>traps</dt>
<dd>Define se o Sinatra deve lidar com sinais do sistema.</dd>
<dt>views</dt>
<dd>
Caminho para o diretório de views. Deduzido da configuração
<tt>app_file</tt> se não estiver definido.
</dd>
<dt>x_cascade</dt>
<dd>
Se deve ou não definir o cabeçalho X-Cascade se nenhuma rota combinar.
Definido como padrão <tt>true</tt>
</dd>
</dl>
## Ambientes
Existem três `environments` (ambientes) pré-definidos: `"development"`
(desenvolvimento), `"production"` (produção) e `"test"` (teste). Ambientes
podem ser definidos através da variável de ambiente `APP_ENV`. O valor padrão é
`"development"`. No ambiente `"development"` todos os templates são
recarregados entre as requisições e manipuladores especiais como `not_found` e
`error` exibem relatórios de erros no seu navegador. Nos ambientes de
`"production"` e `"test"`, os templates são guardados em cache por padrão.
Para rodar diferentes ambientes, defina a variável de ambiente `APP_ENV`:
```shell
APP_ENV=production ruby minha_app.rb
```
Você pode usar métodos pré-definidos: `development?`, `test?` e `production?`
para checar a configuração atual de ambiente:
```ruby
get '/' do
if settings.development?
"desenvolvimento!"
else
"não está em desenvolvimento!"
end
end
```
## Tratamento de Erros
Manipuladores de erros rodam dentro do mesmo contexto como rotas e filtros
before, o que significa que você pega todos os "presentes" que eles têm para
oferecer, como `haml`, `erb`, `halt`, etc.
### Não Encontrado
Quando uma exceção `Sinatra::NotFound` é lançada, ou o código de
status da reposta é 404, o manipulador `not_found` é invocado:
```ruby
not_found do
'Isto está longe de ser encontrado'
end
```
### Erro
O manipulador `error` é invocado toda a vez que uma exceção é lançada a
partir de um bloco de rota ou um filtro. Note que em desenvolvimento, ele irá
rodar apenas se você tiver definido a opção para exibir exceções em
`:after_handler`:
```ruby
set :show_exceptions, :after_handler
```
O objeto da exceção pode ser
obtido a partir da variável Rack `sinatra.error`:
```ruby
error do
'Desculpe, houve um erro desagradável - ' + env['sinatra.error'].message
end
```
Erros customizados:
```ruby
error MeuErroCustomizado do
'Então que aconteceu foi...' + env['sinatra.error'].message
end
```
Então, se isso acontecer:
```ruby
get '/' do
raise MeuErroCustomizado, 'alguma coisa ruim'
end
```
Você receberá isso:
```
Então que aconteceu foi... alguma coisa ruim
````
Alternativamente, você pode instalar um manipulador de erro para um código
de status:
```ruby
error 403 do
'Accesso negado'
end
get '/secreto' do
403
end
```
Ou um alcance:
```ruby
error 400..510 do
'Boom'
end
```
O Sinatra instala os manipuladores especiais `not_found` e `error`
quando roda sobre o ambiente de desenvolvimento para exibir relatórios de erros
bonitos e informações adicionais de "debug" no seu navegador.
## Rack Middleware
O Sinatra roda no [Rack](http://rack.github.io/), uma interface
padrão mínima para frameworks web em Ruby. Um das capacidades mais
interessantes do Rack para desenvolver aplicativos é suporte a
“middleware” – componentes que ficam entre o servidor e sua aplicação
monitorando e/ou manipulando o request/response do HTTP para prover
vários tipos de funcionalidades comuns.
O Sinatra faz construtores pipelines do middleware Rack facilmente em um
nível superior utilizando o método `use`:
```ruby
require 'sinatra'
require 'meu_middleware_customizado'
use Rack::Lint
use MeuMiddlewareCustomizado
get '/ola' do
'Olá mundo'
end
```
A semântica de `use` é idêntica aquela definida para a DSL
[Rack::Builder](http://www.rubydoc.info/github/rack/rack/master/Rack/Builder)
(mais frequentemente utilizada para arquivos rackup). Por exemplo, o
método `use` aceita múltiplos argumentos/variáveis bem como blocos:
```ruby
use Rack::Auth::Basic do |usuario, senha|
usuario == 'admin' && senha == 'secreto'
end
```
O Rack é distribuído com uma variedade de middleware padrões para logs,
debugs, rotas de URL, autenticação, e manipuladores de sessão. Sinatra
utilizada muitos desses componentes automaticamente baseando sobre
configuração, então, tipicamente você não tem `use` explicitamente.
Você pode achar middlewares utéis em
[rack](https://github.com/rack/rack/tree/master/lib/rack),
[rack-contrib](https://github.com/rack/rack-contrib#readme),
ou em [Rack wiki](https://github.com/rack/rack/wiki/List-of-Middleware).
## Testando
Testes no Sinatra podem ser escritos utilizando qualquer biblioteca ou
framework de teste baseados no Rack.
[Rack::Test](http://gitrdoc.com/brynary/rack-test) é recomendado:
```ruby
require 'minha_aplicacao_sinatra'
require 'minitest/autorun'
require 'rack/test'
class MinhaAplicacaoTeste < Minitest::Test
include Rack::Test::Methods
def app
Sinatra::Application
end
def meu_test_default
get '/'
assert_equal 'Ola Mundo!', last_response.body
end
def teste_com_parâmetros
get '/atender', :name => 'Frank'
assert_equal 'Olá Frank!', last_response.bodymeet
end
def test_com_ambiente_rack
get '/', {}, 'HTTP_USER_AGENT' => 'Songbird'
assert_equal "Você está utilizando o Songbird!", last_response.body
end
end
```
NOTA: Se você está usando o Sinatra no estilo modular, substitua
`Sinatra::Application' acima com o nome da classe da sua aplicação
## Sinatra::Base - Middleware, Bibliotecas e aplicativos modulares
Definir sua aplicação em um nível superior de trabalho funciona bem para
micro aplicativos, mas tem consideráveis inconvenientes na construção de
componentes reutilizáveis como um middleware Rack, metal Rails,
bibliotecas simples como um componente de servidor, ou mesmo extensões
Sinatra. A DSL de nível superior polui o espaço do objeto e assume um
estilo de configuração de micro aplicativos (exemplo: uma simples
arquivo de aplicação, diretórios `./public` e `./views`, logs, página de
detalhes de exceção, etc.). É onde o `Sinatra::Base` entra em jogo:
```ruby
require 'sinatra/base'
class MinhaApp < Sinatra::Base
set :sessions, true
set :foo, 'bar'
get '/' do
'Ola mundo!'
end
end
```
Os métodos disponíveis para subclasses `Sinatra::Base` são exatamente como
aqueles disponíveis via a DSL de nível superior. Aplicações de nível
mais alto podem ser convertidas para componentes `Sinatra::Base` com duas
modificações:
* Seu arquivo deve requerer `sinatra/base` ao invés de `sinatra`; caso
contrário, todos os métodos DSL do Sinatra são importados para o espaço de
nomes principal.
* Coloque as rotas da sua aplicação, manipuladores de erro, filtros e opções
numa subclasse de `Sinatra::Base`.
`Sinatra::Base` é um quadro branco. Muitas opções são desabilitadas por
padrão, incluindo o servidor embutido. Veja [Opções e
Configurações](http://www.sinatrarb.com/configuration.html) para
detalhes de opções disponíveis e seus comportamentos. Se você quer
comportamento mais similar à quando você definiu sua aplicação em nível mais
alto (também conhecido como estilo Clássico), você pode usar subclasses de
`Sinatra::Application`:
```ruby
require 'sinatra/base'
class MinhaApp < Sinatra::Application
get '/' do
'Olá mundo!'
end
end
```
### Estilo Clássico vs. Modular
Ao contrário da crença comum, não há nada de errado com o estilo clássico. Se
encaixa com sua aplicação, você não tem que mudar para uma aplicação modular.
As desvantagens principais de usar o estilo clássico no lugar do estilo modular
é que você ira ter apenas uma aplicação Sinatra por processo Ruby. Se seu plano
é usar mais de uma, mude para o estilo modular. Não há nenhum impedimento para
você misturar os estilos clássico e modular.
Se vai mudar de um estilo para outro, você deve tomar cuidado com algumas
configurações diferentes:
<table>
<tr>
<th>Configuração</th>
<th>Clássico</th>
<th>Modular</th>
<th>Modular</th>
</tr>
<tr>
<td>app_file</td>
<td>arquivo carregando sinatra</td>
<td>arquivo usando subclasse Sinatra::Base</td>
<td>arquivo usando subclasse Sinatra::Application</td>
</tr>
<tr>
<td>run</td>
<td>$0 == app_file</td>
<td>false</td>
<td>false</td>
</tr>
<tr>
<td>logging</td>
<td>true</td>
<td>false</td>
<td>true</td>
</tr>
<tr>
<td>method_override</td>
<td>true</td>
<td>false</td>
<td>true</td>
</tr>
<tr>
<td>inline_templates</td>
<td>true</td>
<td>false</td>
<td>true</td>
</tr>
<tr>
<td>static</td>
<td>true</td>
<td>File.exist?(public_folder)</td>
<td>true</td>
</tr>
</table>
### Servindo uma Aplicação Modular:
Existem duas opções comuns para começar uma aplicação modular, ativamente
começando com `run!`:
```ruby
# minha_app.rb
require 'sinatra/base'
class MinhaApp < Sinatra::Base
# ... código da aplicação aqui ...
# inicie o servidor se o arquivo ruby foi executado diretamente
run! if app_file == $0
end
```
Inicie com with:
```shell
ruby minha_app.rb
```
Ou com um arquivo `config.ru`, que permite você usar qualquer manipulador Rack:
```ruby
# config.ru (roda com rackup)
require './minha_app'
run MinhaApp
```
Rode:
```shell
rackup -p 4567
```
### Usando uma Aplicação de Estilo Clássico com um config.ru:
Escreva o arquivo da sua aplicação:
```ruby
# app.rb
require 'sinatra'
get '/' do
'Olá mundo!'
end
```
E um `config.ru` correspondente:
```ruby
require './app'
run Sinatra::Application
```
### Quando usar um config.ru?
Um arquivo `config.ru` é recomendado se:
* Você quer lançar com um manipulador Rack diferente (Passenger, Unicorn,
Heroku, ...).
* Você quer usar mais de uma subclasse de `Sinatra::Base`.
* Você quer usar Sinatra apenas como middleware, mas não como um "endpoint".
**Não há necessidade de mudar para um `config.ru` simplesmente porque você mudou para o estilo modular, e você não tem que usar o estilo modular para rodar com um `config.ru`.**
### Usando Sinatra como Middleware
O Sinatra não é capaz apenas de usar outro middleware Rack, qualquer aplicação
Sinatra pode ser adicionada na frente de qualquer "endpoint" Rack como
middleware. Esse endpoint pode ser outra aplicação Sinatra, ou qualquer outra
aplicação baseada em Rack (Rails/Hanami/Roda/...):
```ruby
require 'sinatra/base'
class TelaLogin < Sinatra::Base
enable :sessions
get('/login') { haml :login }
post('/login') do
if params['nome'] == 'admin' && params['senha'] == 'admin'
session['nome_usuario'] = params['nome']
else
redirect '/login'
end
end
end
class MinhaApp < Sinatra::Base
# middleware irá rodar filtros before
use TelaLogin
before do
unless session['nome_usuario']
halt "Acesso negado, por favor <a href='/login'>login</a>."
end
end
get('/') { "Olá #{session['nome_usuario']}." }
end
```
### Criação de Aplicações Dinâmicas
Às vezes, você quer criar novas aplicações em tempo de execução sem ter que
associa-las a uma constante. Você pode fazer isso com `Sinatra.new`:
```ruby
require 'sinatra/base'
minha_app = Sinatra.new { get('/') { "oi" } }
minha_app.run!
```
Isso leva a aplicação à herdar como um argumento opcional:
```ruby
# config.ru (roda com rackup)
require 'sinatra/base'
controller = Sinatra.new do
enable :logging
helpers MeusHelpers
end
map('/a') do
run Sinatra.new(controller) { get('/') { 'a' } }
end
map('/b') do
run Sinatra.new(controller) { get('/') { 'b' } }
end
```
Isso é especialmente útil para testar extensões do Sinatra ou usar Sinatra na
sua própria biblioteca.
Isso também faz o uso do Sinatra como middleware extremamente fácil:
```ruby
require 'sinatra/base'
use Sinatra do
get('/') { ... }
end
run RailsProject::Application
```
# Escopos e Ligação
O escopo que você está atualmente determina quais métodos e varáveis está
disponíveis.
### Escopo de Aplicação/Classe
Toda aplicação Sinatra corresponde à um subclasse de `Sinatra::Base`. Se você
está utilizando a DSL de nível mais alto (`require 'sinatra`), então esta
classe é `Sinatra::Application`, caso contrário é a subclasse que você criou
explicitamente. No nível de classe você tem métodos como `get` ou `before`, mas
você não pode acessar os objetos `request` ou `session`, como existe apenas uma
única classe de aplicativo para todas as solicitações.
Opções criadas via `set` são métodos a nível de classe:
```ruby
class MinhaApp < Sinatra::Base
# Hey, eu estou no escopo da aplicação!
set :foo, 42
foo # => 42
get '/foo' do
# Hey, eu não estou mais no escopo da aplicação!
end
end
```
Você tem a ligação ao escopo da aplicação dentro:
* Do corpo da classe da sua aplicação
* De métodos definidos por extensões
* Do bloco passado a `helpers`
* De Procs/Blocos usados como valor para `set``
* Do bloco passado a `Sinatra.new``
Você pode atingir o escopo do objeto (a classe) de duas maneiras:
* Por meio do objeto passado aos blocos "configure" (`configure { |c| ...}`)
* `settings` de dentro do escopo da requisição
### Escopo de Instância/Requisição
Para toda requisição que chega, uma nova instância da classe da sua aplicação é
criada e todos blocos de manipulação rodam nesse escopo. Dentro desse escopo
você pode acessar os objetos `request` e `session` ou chamar métodos de
renderização como `erb` ou `haml`. Você pode acessar o escopo da aplicação de
dentro do escopo da requisição através do método auxiliar `settings`:
```ruby
class MinhaApp < Sinatra::Base
# Hey, eu estou no escopo da aplicação!
get '/define_rota/:nome' do
# Escopo da requisição para '/define_rota/:nome'
@valor = 42
settings.get("/#{params['nome']}") do
# Escopo da requisição para "/#{params['nome']}"
@valor # => nil (não é a mesma requisição)
end
"Rota definida!"
end
end
```
Você tem a ligação ao escopo da requisição dentro dos:
* blocos get, head, post, put, delete, options, patch, link e unlink
* filtros after e before
* métodos "helper" (auxiliares)
* templates/views
### Escopo de Delegação
O escopo de delegação apenas encaminha métodos ao escopo da classe. Entretanto,
ele não se comporta exatamente como o escopo da classe já que você não tem a
ligação da classe. Apenas métodos marcados explicitamente para delegação
estarão disponíveis e você não compartilha variáveis/estado com o escopo da
classe (leia: você tem um `self` diferente). Você pode explicitamente adicionar
delegações de métodos chamando `Sinatra::Delegator.delegate :method_name`.
Você tem a ligação com o escopo delegado dentro:
* Da ligação de maior nível, se você digitou `require "sinatra"`
* De um objeto estendido com o mixin `Sinatra::Delegator`
Dê uma olhada no código você mesmo: aqui está [Sinatra::Delegator mixin](https://github.com/sinatra/sinatra/blob/ca06364/lib/sinatra/base.rb#L1609-1633) em [estendendo o objeto principal](https://github.com/sinatra/sinatra/blob/ca06364/lib/sinatra/main.rb#L28-30).
## Linha de Comando
Aplicações Sinatra podem ser executadas diretamente:
```shell
ruby minhaapp.rb [-h] [-x] [-q] [-e AMBIENTE] [-p PORTA] [-o HOST] [-s MANIPULADOR]
```
As opções são:
```
-h # ajuda
-p # define a porta (padrão é 4567)
-o # define o host (padrão é 0.0.0.0)
-e # define o ambiente (padrão é development)
-s # especifica o servidor/manipulador rack (padrão é thin)
-x # ativa o bloqueio mutex (padrão é desligado)
```
### Multi-threading
_Parafraseando [esta resposta no StackOverflow](resposta-so) por Konstantin_
Sinatra não impõe nenhum modelo de concorrência, mas deixa isso como
responsabilidade do Rack (servidor) subjacente como o Thin, Puma ou WEBrick.
Sinatra por si só é thread-safe, então não há nenhum problema se um Rack
handler usar um modelo de thread de concorrência. Isso significaria que ao
iniciar o servidor, você teria que especificar o método de invocação correto
para o Rack handler específico. Os seguintes exemplos é uma demonstração de
como iniciar um servidor Thin multi-thread:
```ruby
# app.rb
require 'sinatra/base'
class App < Sinatra::Base
get '/' do
'Olá mundo'
end
end
App.run!
```
Para iniciar o servidor seria:
```shell
thin --threaded start
```
## Requerimentos
As seguintes versões do Ruby são oficialmente suportadas:
<dl>
<dt>Ruby 2.2</dt>
<dd>
2.2 é totalmente suportada e recomendada. Atualmente não existem planos
para para o suporte oficial para ela.
</dd>
<dt>Rubinius</dt>
<dd>
Rubinius é oficialmente suportado (Rubinius >= 2.x). É recomendado rodar
<tt>gem install puma</tt>.
</dd>
<dt>JRuby</dt>
<dd>
A última versão estável lançada do JRuby é oficialmente suportada. Não é
recomendado usar extensões em C com o JRuby. É recomendado rodar
<tt>gem install trinidad</tt>.
</dd>
</dl>
Versões do Ruby antes da 2.2.2 não são mais suportadas pelo Sinatra 2.0.
Nós também estamos de olhos em versões futuras do Ruby.
As seguintes implementações do Ruby não são oficialmente suportadas mas sabemos
que rodam o Sinatra:
* Versões antigas do JRuby e Rubinius
* Ruby Enterprise Edition
* MacRuby, Maglev, IronRuby
* Ruby 1.9.0 e 1.9.1 (mas nós não recomendamos o uso dessas)
Não ser oficialmente suportada significa que se algo quebrar e não estiver nas
plataformas suporta, iremos assumir que não é um problema nosso e sim das
plataformas.
Nós também rodas nossa IC sobre ruby-head (lançamentos futuros do MRI), mas nós
não podemos garantir nada, já que está em constante mudança. Espera-se que
lançamentos futuros da versão 2.x sejam totalmente suportadas.
Sinatra deve funcionar em qualquer sistema operacional suportado pela
implementação Ruby escolhida.
Se você rodar MacRuby, você deve rodar `gem install control_tower`.
O Sinatra atualmente não roda em Cardinal, SmallRuby, BlueRuby ou qualquer
versão do Ruby anterior ao 2.2.
## A última versão
Se você gostaria de utilizar o código da última versão do Sinatra, sinta-se
livre para rodar a aplicação com o ramo master, ele deve ser estável.
Nós também lançamos pré-lançamentos de gems de tempos em tempos, então você
pode fazer:
```shell
gem install sinatra --pre
```
para obter alguma das últimas funcionalidades.
### Com Bundler
Se você quer rodar sua aplicação com a última versão do Sinatra usando
[Bundler](https://bundler.io) é recomendado fazer dessa forma.
Primeiramente, instale o Bundler, se você ainda não tiver:
```shell
gem install bundler
```
Então, no diretório do seu projeto, crie uma `Gemfile`:
```ruby
source 'https://rubygems.org'
gem 'sinatra', :github => 'sinatra/sinatra'
# outras dependências
gem 'haml' # por exemplo, se você usar haml
```
Perceba que você terá que listar todas suas dependências de aplicação no
`Gemfile`. As dependências diretas do Sinatra (Rack e Tilt) irão, entretanto,
ser automaticamente recuperadas e adicionadas pelo Bundler.
Então você pode rodar sua aplicação assim:
```shell
bundle exec ruby myapp.rb
```
## Versionando
O Sinatras segue [Versionamento Semântico](https://semver.org/), tanto SemVer
como SemVerTag.
## Mais
* [Website do Projeto](http://www.sinatrarb.com/) - Documentação
adicional, novidades e links para outros recursos.
* [Contribuir](http://www.sinatrarb.com/contributing) - Encontrou um
bug? Precisa de ajuda? Tem um patch?
* [Acompanhar Problemas](https://github.com/sinatra/sinatra/issues)
* [Twitter](https://twitter.com/sinatra)
* [Lista de Email](http://groups.google.com/group/sinatrarb/topics)
* [Sinatra & Amigos](https://sinatrarb.slack.com) no Slack
([consiga um convite](https://sinatra-slack.herokuapp.com/))
* [Sinatra Book](https://github.com/sinatra/sinatra-book/) - Livro de "Receitas"
* [Sinatra Recipes](http://recipes.sinatrarb.com/) - "Receitas" de
contribuições da comunidade
* Documentação da API para a
[última release](http://www.rubydoc.info/gems/sinatra)
ou para o [HEAD atual](http://www.rubydoc.info/github/sinatra/sinatra)
no [Ruby Doc](http://www.rubydoc.info/)
* [Servidor de CI](https://travis-ci.org/sinatra/sinatra)
View Git Blame Copy Permalink