sinatra-acd 1.4.5

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (128) hide show
  1. checksums.yaml +7 -0
  2. data/.yardopts +5 -0
  3. data/AUTHORS +61 -0
  4. data/CHANGES +1293 -0
  5. data/Gemfile +76 -0
  6. data/LICENSE +23 -0
  7. data/README.de.md +2864 -0
  8. data/README.es.md +2786 -0
  9. data/README.fr.md +2924 -0
  10. data/README.hu.md +694 -0
  11. data/README.ja.md +2726 -0
  12. data/README.ko.md +2832 -0
  13. data/README.md +2980 -0
  14. data/README.pt-br.md +965 -0
  15. data/README.pt-pt.md +791 -0
  16. data/README.ru.md +2799 -0
  17. data/README.zh.md +2158 -0
  18. data/Rakefile +199 -0
  19. data/examples/chat.rb +61 -0
  20. data/examples/simple.rb +3 -0
  21. data/examples/stream.ru +26 -0
  22. data/lib/sinatra.rb +4 -0
  23. data/lib/sinatra/base.rb +2044 -0
  24. data/lib/sinatra/images/404.png +0 -0
  25. data/lib/sinatra/images/500.png +0 -0
  26. data/lib/sinatra/main.rb +34 -0
  27. data/lib/sinatra/show_exceptions.rb +345 -0
  28. data/lib/sinatra/version.rb +3 -0
  29. data/sinatra.gemspec +19 -0
  30. data/test/asciidoctor_test.rb +72 -0
  31. data/test/base_test.rb +171 -0
  32. data/test/builder_test.rb +91 -0
  33. data/test/coffee_test.rb +90 -0
  34. data/test/compile_test.rb +183 -0
  35. data/test/contest.rb +100 -0
  36. data/test/creole_test.rb +65 -0
  37. data/test/delegator_test.rb +160 -0
  38. data/test/encoding_test.rb +20 -0
  39. data/test/erb_test.rb +116 -0
  40. data/test/extensions_test.rb +98 -0
  41. data/test/filter_test.rb +487 -0
  42. data/test/haml_test.rb +109 -0
  43. data/test/helper.rb +131 -0
  44. data/test/helpers_test.rb +1917 -0
  45. data/test/integration/app.rb +79 -0
  46. data/test/integration_helper.rb +236 -0
  47. data/test/integration_test.rb +104 -0
  48. data/test/less_test.rb +69 -0
  49. data/test/liquid_test.rb +77 -0
  50. data/test/mapped_error_test.rb +285 -0
  51. data/test/markaby_test.rb +80 -0
  52. data/test/markdown_test.rb +82 -0
  53. data/test/mediawiki_test.rb +68 -0
  54. data/test/middleware_test.rb +68 -0
  55. data/test/nokogiri_test.rb +67 -0
  56. data/test/public/favicon.ico +0 -0
  57. data/test/rabl_test.rb +89 -0
  58. data/test/rack_test.rb +45 -0
  59. data/test/radius_test.rb +59 -0
  60. data/test/rdoc_test.rb +66 -0
  61. data/test/readme_test.rb +130 -0
  62. data/test/request_test.rb +97 -0
  63. data/test/response_test.rb +63 -0
  64. data/test/result_test.rb +76 -0
  65. data/test/route_added_hook_test.rb +59 -0
  66. data/test/routing_test.rb +1412 -0
  67. data/test/sass_test.rb +115 -0
  68. data/test/scss_test.rb +88 -0
  69. data/test/server_test.rb +48 -0
  70. data/test/settings_test.rb +582 -0
  71. data/test/sinatra_test.rb +12 -0
  72. data/test/slim_test.rb +102 -0
  73. data/test/static_test.rb +236 -0
  74. data/test/streaming_test.rb +149 -0
  75. data/test/stylus_test.rb +90 -0
  76. data/test/templates_test.rb +382 -0
  77. data/test/textile_test.rb +65 -0
  78. data/test/views/a/in_a.str +1 -0
  79. data/test/views/ascii.erb +2 -0
  80. data/test/views/b/in_b.str +1 -0
  81. data/test/views/calc.html.erb +1 -0
  82. data/test/views/error.builder +3 -0
  83. data/test/views/error.erb +3 -0
  84. data/test/views/error.haml +3 -0
  85. data/test/views/error.sass +2 -0
  86. data/test/views/explicitly_nested.str +1 -0
  87. data/test/views/foo/hello.test +1 -0
  88. data/test/views/hello.asciidoc +1 -0
  89. data/test/views/hello.builder +1 -0
  90. data/test/views/hello.coffee +1 -0
  91. data/test/views/hello.creole +1 -0
  92. data/test/views/hello.erb +1 -0
  93. data/test/views/hello.haml +1 -0
  94. data/test/views/hello.less +5 -0
  95. data/test/views/hello.liquid +1 -0
  96. data/test/views/hello.mab +1 -0
  97. data/test/views/hello.md +1 -0
  98. data/test/views/hello.mediawiki +1 -0
  99. data/test/views/hello.nokogiri +1 -0
  100. data/test/views/hello.rabl +2 -0
  101. data/test/views/hello.radius +1 -0
  102. data/test/views/hello.rdoc +1 -0
  103. data/test/views/hello.sass +2 -0
  104. data/test/views/hello.scss +3 -0
  105. data/test/views/hello.slim +1 -0
  106. data/test/views/hello.str +1 -0
  107. data/test/views/hello.styl +2 -0
  108. data/test/views/hello.test +1 -0
  109. data/test/views/hello.textile +1 -0
  110. data/test/views/hello.wlang +1 -0
  111. data/test/views/hello.yajl +1 -0
  112. data/test/views/layout2.builder +3 -0
  113. data/test/views/layout2.erb +2 -0
  114. data/test/views/layout2.haml +2 -0
  115. data/test/views/layout2.liquid +2 -0
  116. data/test/views/layout2.mab +2 -0
  117. data/test/views/layout2.nokogiri +3 -0
  118. data/test/views/layout2.rabl +3 -0
  119. data/test/views/layout2.radius +2 -0
  120. data/test/views/layout2.slim +3 -0
  121. data/test/views/layout2.str +2 -0
  122. data/test/views/layout2.test +1 -0
  123. data/test/views/layout2.wlang +2 -0
  124. data/test/views/nested.str +1 -0
  125. data/test/views/utf8.erb +2 -0
  126. data/test/wlang_test.rb +87 -0
  127. data/test/yajl_test.rb +86 -0
  128. metadata +280 -0
@@ -0,0 +1,965 @@
1
+ # Sinatra
2
+
3
+ *Atenção: Este documento é apenas uma tradução da versão em inglês e
4
+ pode estar desatualizado.*
5
+
6
+ Alguns dos trechos de códigos a seguir utilizam caracteres UTF-8, então caso esteja utilizando uma versão de ruby inferior a `2.0.0` adicione o enconding no início de seus arquivos:
7
+
8
+ ```ruby
9
+ # encoding: utf-8
10
+ ```
11
+
12
+ Sinatra é uma [DSL](http://pt.wikipedia.org/wiki/Linguagem_de_domínio_específico) para
13
+ criar aplicações web em Ruby com o mínimo de esforço e rapidez:
14
+
15
+ ``` ruby
16
+ # minha_app.rb
17
+ require 'sinatra'
18
+
19
+ get '/' do
20
+ 'Olá Mundo!'
21
+ end
22
+ ```
23
+
24
+ Instale a gem:
25
+
26
+ ``` shell
27
+ gem install sinatra
28
+ ```
29
+
30
+ Em seguida execute:
31
+
32
+ ``` shell
33
+ ruby minha_app.rb
34
+ ```
35
+
36
+ Acesse: [localhost:4567](http://localhost:4567)
37
+
38
+ É recomendado também executar `gem install thin`. Caso esta gem esteja disponível, o
39
+ Sinatra irá utilizá-la.
40
+
41
+
42
+ ## Rotas
43
+
44
+ No Sinatra, uma rota é um método HTTP emparelhado com um padrão de URL.
45
+ Cada rota possui um bloco de execução:
46
+
47
+ ``` ruby
48
+ get '/' do
49
+ .. mostrando alguma coisa ..
50
+ end
51
+
52
+ post '/' do
53
+ .. criando alguma coisa ..
54
+ end
55
+
56
+ put '/' do
57
+ .. atualizando alguma coisa ..
58
+ end
59
+
60
+ patch '/' do
61
+ .. modificando alguma coisa ..
62
+ end
63
+
64
+ delete '/' do
65
+ .. removendo alguma coisa ..
66
+ end
67
+
68
+ options '/' do
69
+ .. estabelecendo alguma coisa ..
70
+ end
71
+ ```
72
+
73
+ As rotas são interpretadas na ordem em que são definidas. A primeira
74
+ rota encontrada responde ao pedido.
75
+
76
+ Padrões de rota podem conter parâmetros nomeados, acessível através do
77
+ hash `params`:
78
+
79
+ ``` ruby
80
+ get '/ola/:nome' do
81
+ # corresponde a "GET /ola/foo" e "GET /ola/bar"
82
+ # params[:nome] é 'foo' ou 'bar'
83
+ "Olá #{params[:nome]}!"
84
+ end
85
+ ```
86
+
87
+ Você também pode acessar parâmetros nomeados através dos parâmetros de
88
+ um bloco:
89
+
90
+ ``` ruby
91
+ get '/ola/:nome' do |n|
92
+ "Olá #{n}!"
93
+ end
94
+ ```
95
+
96
+ Padrões de rota também podem conter parâmetros splat (wildcard),
97
+ acessível através do array `params[: splat]`:
98
+
99
+ ``` ruby
100
+ get '/diga/*/para/*' do
101
+ # corresponde a /diga/ola/para/mundo
102
+ params[:splat] # => ["ola", "mundo"]
103
+ end
104
+
105
+ get '/download/*.*' do
106
+ # corresponde a /download/pasta/do/arquivo.xml
107
+ params[:splat] # => ["pasta/do/arquivo", "xml"]
108
+ end
109
+ ```
110
+
111
+ Ou com parâmetros de um bloco:
112
+
113
+ ``` ruby
114
+ get '/download/*.*' do |pasta, ext|
115
+ [pasta, ext] # => ["pasta/do/arquivo", "xml"]
116
+ end
117
+ ```
118
+
119
+ Rotas podem corresponder com expressões regulares:
120
+
121
+ ``` ruby
122
+ get %r{/ola/([\w]+)} do
123
+ "Olá, #{params[:captures].first}!"
124
+ end
125
+ ```
126
+
127
+ Ou com parâmetros de um bloco:
128
+
129
+ ``` ruby
130
+ get %r{/ola/([\w]+)} do |c|
131
+ "Olá, #{c}!"
132
+ end
133
+ ```
134
+
135
+ Padrões de rota podem contar com parâmetros opcionais:
136
+
137
+ ``` ruby
138
+ get '/posts.?:formato?' do
139
+ # corresponde a "GET /posts" e qualquer extensão "GET /posts.json", "GET /posts.xml", etc.
140
+ end
141
+ ```
142
+
143
+ A propósito, a menos que você desative a proteção contra ataques (veja
144
+ abaixo), o caminho solicitado pode ser alterado antes de concluir a
145
+ comparação com as suas rotas.
146
+
147
+ ### Condições
148
+
149
+ Rotas podem incluir uma variedade de condições, tal como o `user agent`:
150
+
151
+ ``` ruby
152
+ get '/foo', :agent => /Songbird (\d\.\d)[\d\/]*?/ do
153
+ "Você está usando o Songbird versão #{params[:agent][0]}"
154
+ end
155
+
156
+ get '/foo' do
157
+ # Correspondente a navegadores que não sejam Songbird
158
+ end
159
+ ```
160
+
161
+ Outras condições disponíveis são `host_name` e `provides`:
162
+
163
+ ``` ruby
164
+ get '/', :host_name => /^admin\./ do
165
+ "Área administrativa. Acesso negado!"
166
+ end
167
+
168
+ get '/', :provides => 'html' do
169
+ haml :index
170
+ end
171
+
172
+ get '/', :provides => ['rss', 'atom', 'xml'] do
173
+ builder :feed
174
+ end
175
+ ```
176
+
177
+ Você pode facilmente definir suas próprias condições:
178
+
179
+ ``` ruby
180
+ set(:probabilidade) { |valor| condition { rand <= valor } }
181
+
182
+ get '/ganha_um_carro', :probabilidade => 0.1 do
183
+ "Você ganhou!"
184
+ end
185
+
186
+ get '/ganha_um_carro' do
187
+ "Sinto muito, você perdeu."
188
+ end
189
+ ```
190
+
191
+ Use splat, para uma condição que levam vários valores:
192
+
193
+ ``` ruby
194
+ set(:auth) do |*roles| # <- observe o splat aqui
195
+ condition do
196
+ unless logged_in? && roles.any? {|role| current_user.in_role? role }
197
+ redirect "/login/", 303
198
+ end
199
+ end
200
+ end
201
+
202
+ get "/minha/conta/", :auth => [:usuario, :administrador] do
203
+ "Detalhes da sua conta"
204
+ end
205
+
206
+ get "/apenas/administrador/", :auth => :administrador do
207
+ "Apenas administradores são permitidos aqui!"
208
+ end
209
+ ```
210
+
211
+ ### Retorno de valores
212
+
213
+ O valor de retorno do bloco de uma rota determina pelo menos o corpo da
214
+ resposta passado para o cliente HTTP, ou pelo menos o próximo middleware
215
+ na pilha Rack. Frequentemente, isto é uma `string`, tal como nos
216
+ exemplos acima. Mas, outros valores também são aceitos.
217
+
218
+ Você pode retornar uma resposta válida ou um objeto para o Rack, sendo
219
+ eles de qualquer tipo de objeto que queira. Além disto, é possível
220
+ retornar um código de status HTTP.
221
+
222
+ - Um array com três elementros: `[status (Fixnum), cabecalho (Hash),
223
+ corpo da resposta (responde à #each)]`
224
+
225
+ - Um array com dois elementros: `[status (Fixnum), corpo da resposta
226
+ (responde à #each)]`
227
+
228
+ - Um objeto que responda à `#each` sem passar nada, mas, sim, `strings`
229
+ para um dado bloco
230
+
231
+ - Um objeto `Fixnum` representando o código de status
232
+
233
+ Dessa forma, podemos implementar facilmente um exemplo de streaming:
234
+
235
+ ``` ruby
236
+ class Stream
237
+ def each
238
+ 100.times { |i| yield "#{i}\n" }
239
+ end
240
+ end
241
+
242
+ get('/') { Stream.new }
243
+ ```
244
+
245
+ Você também pode usar o método auxiliar `stream` (descrito abaixo) para
246
+ incorporar a lógica de streaming na rota.
247
+
248
+ ### Custom Route Matchers
249
+
250
+ Como apresentado acima, a estrutura do Sinatra conta com suporte
251
+ embutido para uso de padrões de String e expressões regulares como
252
+ validadores de rota. No entanto, ele não pára por aí. Você pode
253
+ facilmente definir os seus próprios validadores:
254
+
255
+ ``` ruby
256
+ class AllButPattern
257
+ Match = Struct.new(:captures)
258
+
259
+ def initialize(except)
260
+ @except = except
261
+ @captures = Match.new([])
262
+ end
263
+
264
+ def match(str)
265
+ @captures unless @except === str
266
+ end
267
+ end
268
+
269
+ def all_but(pattern)
270
+ AllButPattern.new(pattern)
271
+ end
272
+
273
+ get all_but("/index") do
274
+ # ...
275
+ end
276
+ ```
277
+
278
+ Note que o exemplo acima pode ser robusto e complicado em excesso. Pode
279
+ também ser implementado como:
280
+
281
+ ``` ruby
282
+ get // do
283
+ pass if request.path_info == "/index"
284
+ # ...
285
+ end
286
+ ```
287
+
288
+ Ou, usando algo mais denso à frente:
289
+
290
+ ``` ruby
291
+ get %r{^(?!/index$)} do
292
+ # ...
293
+ end
294
+ ```
295
+
296
+ ## Arquivos estáticos
297
+
298
+ Arquivos estáticos são disponibilizados a partir do diretório
299
+ `./public`. Você pode especificar um local diferente pela opção
300
+ `:public_folder`
301
+
302
+ ``` ruby
303
+ set :public_folder, File.dirname(__FILE__) + '/estatico'
304
+ ```
305
+
306
+ Note que o nome do diretório público não é incluido na URL. Um arquivo
307
+ `./public/css/style.css` é disponibilizado como
308
+ `http://example.com/css/style.css`.
309
+
310
+ ## Views / Templates
311
+
312
+ Templates presumem-se estar localizados sob o diretório `./views`. Para
313
+ utilizar um diretório view diferente:
314
+
315
+ ``` ruby
316
+ set :views, File.dirname(__FILE__) + '/modelo'
317
+ ```
318
+
319
+ Uma coisa importante a ser lembrada é que você sempre tem as referências
320
+ dos templates como símbolos, mesmo se eles estiverem em um sub-diretório
321
+ (nesse caso utilize `:'subdir/template'`). Métodos de renderização irão
322
+ processar qualquer string passada diretamente para elas.
323
+
324
+ ### Haml Templates
325
+
326
+ A gem/biblioteca haml é necessária para renderizar templates HAML:
327
+
328
+ ``` ruby
329
+ # Você precisa do 'require haml' em sua aplicação.
330
+ require 'haml'
331
+
332
+ get '/' do
333
+ haml :index
334
+ end
335
+ ```
336
+
337
+ Renderiza `./views/index.haml`.
338
+
339
+ [Opções
340
+ Haml](http://haml.info/docs/yardoc/file.HAML_REFERENCE.html#options)
341
+ podem ser setadas globalmente através das configurações do sinatra, veja
342
+ [Opções e Configurações](http://www.sinatrarb.com/configuration.html), e
343
+ substitua em uma requisição individual.
344
+
345
+ ``` ruby
346
+ set :haml, {:format => :html5 } # o formato padrão do Haml é :xhtml
347
+
348
+ get '/' do
349
+ haml :index, :haml_options => {:format => :html4 } # substituido
350
+ end
351
+ ```
352
+
353
+ ### Erb Templates
354
+
355
+ ``` ruby
356
+ # Você precisa do 'require erb' em sua aplicação
357
+ require 'erb'
358
+
359
+ get '/' do
360
+ erb :index
361
+ end
362
+ ```
363
+
364
+ Renderiza `./views/index.erb`
365
+
366
+ ### Erubis
367
+
368
+ A gem/biblioteca erubis é necessária para renderizar templates erubis:
369
+
370
+ ``` ruby
371
+ # Você precisa do 'require erubis' em sua aplicação.
372
+ require 'erubis'
373
+
374
+ get '/' do
375
+ erubis :index
376
+ end
377
+ ```
378
+
379
+ Renderiza `./views/index.erubis`
380
+
381
+ ### Builder Templates
382
+
383
+ A gem/biblioteca builder é necessária para renderizar templates builder:
384
+
385
+ ``` ruby
386
+ # Você precisa do 'require builder' em sua aplicação.
387
+ require 'builder'
388
+
389
+ get '/' do
390
+ content_type 'application/xml', :charset => 'utf-8'
391
+ builder :index
392
+ end
393
+ ```
394
+
395
+ Renderiza `./views/index.builder`.
396
+
397
+ ### Sass Templates
398
+
399
+ A gem/biblioteca sass é necessária para renderizar templates sass:
400
+
401
+ ``` ruby
402
+ # Você precisa do 'require haml' ou 'require sass' em sua aplicação.
403
+ require 'sass'
404
+
405
+ get '/stylesheet.css' do
406
+ content_type 'text/css', :charset => 'utf-8'
407
+ sass :stylesheet
408
+ end
409
+ ```
410
+
411
+ Renderiza `./views/stylesheet.sass`.
412
+
413
+ [Opções
414
+ Sass](http://sass-lang.com/docs/yardoc/file.SASS_REFERENCE.html#options)
415
+ podem ser setadas globalmente através das configurações do sinatra, veja
416
+ [Opções e Configurações](http://www.sinatrarb.com/configuration.html), e
417
+ substitua em uma requisição individual.
418
+
419
+ ``` ruby
420
+ set :sass, {:style => :compact } # o estilo padrão do Sass é :nested
421
+
422
+ get '/stylesheet.css' do
423
+ content_type 'text/css', :charset => 'utf-8'
424
+ sass :stylesheet, :style => :expanded # substituido
425
+ end
426
+ ```
427
+
428
+ ### Less Templates
429
+
430
+ A gem/biblioteca less é necessária para renderizar templates Less:
431
+
432
+ ``` ruby
433
+ # Você precisa do 'require less' em sua aplicação.
434
+ require 'less'
435
+
436
+ get '/stylesheet.css' do
437
+ content_type 'text/css', :charset => 'utf-8'
438
+ less :stylesheet
439
+ end
440
+ ```
441
+
442
+ Renderiza `./views/stylesheet.less`.
443
+
444
+ ### Inline Templates
445
+
446
+ ``` ruby
447
+ get '/' do
448
+ haml '%div.title Olá Mundo'
449
+ end
450
+ ```
451
+
452
+ Renderiza a string, em uma linha, no template.
453
+
454
+ ### Acessando Variáveis nos Templates
455
+
456
+ Templates são avaliados dentro do mesmo contexto como manipuladores de
457
+ rota. Variáveis de instância setadas em rotas manipuladas são
458
+ diretamente acessadas por templates:
459
+
460
+ ``` ruby
461
+ get '/:id' do
462
+ @foo = Foo.find(params[:id])
463
+ haml '%h1= @foo.nome'
464
+ end
465
+ ```
466
+
467
+ Ou, especifique um hash explícito para variáveis locais:
468
+
469
+ ``` ruby
470
+ get '/:id' do
471
+ foo = Foo.find(params[:id])
472
+ haml '%h1= foo.nome', :locals => { :foo => foo }
473
+ end
474
+ ```
475
+
476
+ Isso é tipicamente utilizando quando renderizamos templates como
477
+ partials dentro de outros templates.
478
+
479
+ ### Templates Inline
480
+
481
+ Templates podem ser definidos no final do arquivo fonte(.rb):
482
+
483
+ ``` ruby
484
+ require 'rubygems'
485
+ require 'sinatra'
486
+
487
+ get '/' do
488
+ haml :index
489
+ end
490
+
491
+ __END__
492
+
493
+ @@ layout
494
+ %html
495
+ = yield
496
+
497
+ @@ index
498
+ %div.title Olá Mundo!!!!!
499
+ ```
500
+
501
+ NOTA: Templates inline definidos no arquivo fonte são automaticamente
502
+ carregados pelo sinatra. Digite \`enable :inline\_templates\` se você
503
+ tem templates inline no outro arquivo fonte.
504
+
505
+ ### Templates nomeados
506
+
507
+ Templates também podem ser definidos utilizando o método top-level
508
+ `template`:
509
+
510
+ ``` ruby
511
+ template :layout do
512
+ "%html\n =yield\n"
513
+ end
514
+
515
+ template :index do
516
+ '%div.title Olá Mundo!'
517
+ end
518
+
519
+ get '/' do
520
+ haml :index
521
+ end
522
+ ```
523
+
524
+ Se existir um template com nome “layout”, ele será utilizado toda vez
525
+ que um template for renderizado. Você pode desabilitar layouts passando
526
+ `:layout => false`.
527
+
528
+ ``` ruby
529
+ get '/' do
530
+ haml :index, :layout => !request.xhr?
531
+ end
532
+ ```
533
+
534
+ ## Helpers
535
+
536
+ Use o método de alto nível `helpers` para definir métodos auxiliares
537
+ para utilizar em manipuladores de rotas e modelos:
538
+
539
+ ``` ruby
540
+ helpers do
541
+ def bar(nome)
542
+ "#{nome}bar"
543
+ end
544
+ end
545
+
546
+ get '/:nome' do
547
+ bar(params[:nome])
548
+ end
549
+ ```
550
+
551
+ ## Filtros
552
+
553
+ Filtros Before são avaliados antes de cada requisição dentro do contexto
554
+ da requisição e pode modificar a requisição e a reposta. Variáveis de
555
+ instância setadas nos filtros são acessadas através de rotas e
556
+ templates:
557
+
558
+ ``` ruby
559
+ before do
560
+ @nota = 'Oi!'
561
+ request.path_info = '/foo/bar/baz'
562
+ end
563
+
564
+ get '/foo/*' do
565
+ @nota #=> 'Oi!'
566
+ params[:splat] #=> 'bar/baz'
567
+ end
568
+ ```
569
+
570
+ Filtros After são avaliados após cada requisição dentro do contexto da
571
+ requisição e também podem modificar o pedido e a resposta. Variáveis de
572
+ instância definidas nos filtros before e rotas são acessadas através dos
573
+ filtros after:
574
+
575
+ ``` ruby
576
+ after do
577
+ puts response.status
578
+ end
579
+ ```
580
+
581
+ Filtros opcionalmente tem um padrão, fazendo com que sejam avaliados
582
+ somente se o caminho do pedido coincidir com esse padrão:
583
+
584
+ ``` ruby
585
+ before '/protected/*' do
586
+ authenticate!
587
+ end
588
+
589
+ after '/create/:slug' do |slug|
590
+ session[:last_slug] = slug
591
+ end
592
+ ```
593
+
594
+ ## Halting
595
+
596
+ Para parar imediatamente uma requisição com um filtro ou rota utilize:
597
+
598
+ ``` ruby
599
+ halt
600
+ ```
601
+
602
+ Você também pode especificar o status quando parar…
603
+
604
+ ``` ruby
605
+ halt 410
606
+ ```
607
+
608
+ Ou com corpo de texto…
609
+
610
+ ``` ruby
611
+ halt 'isso será o corpo do texto'
612
+ ```
613
+
614
+ Ou também…
615
+
616
+ ``` ruby
617
+ halt 401, 'vamos embora!'
618
+ ```
619
+
620
+ Com cabeçalhos…
621
+
622
+ ``` ruby
623
+ halt 402, {'Content-Type' => 'text/plain'}, 'revanche'
624
+ ```
625
+
626
+ ## Passing
627
+
628
+ Uma rota pode processar aposta para a próxima rota correspondente usando
629
+ `pass`:
630
+
631
+ ``` ruby
632
+ get '/adivinhar/:quem' do
633
+ pass unless params[:quem] == 'Frank'
634
+ 'Você me pegou!'
635
+ end
636
+
637
+ get '/adivinhar/*' do
638
+ 'Você falhou!'
639
+ end
640
+ ```
641
+
642
+ O bloqueio da rota é imediatamente encerrado e o controle continua com a
643
+ próxima rota de parâmetro. Se o parâmetro da rota não for encontrado, um
644
+ 404 é retornado.
645
+
646
+ ## Configuração
647
+
648
+ Rodando uma vez, na inicialização, em qualquer ambiente:
649
+
650
+ ``` ruby
651
+ configure do
652
+ ...
653
+ end
654
+ ```
655
+
656
+ Rodando somente quando o ambiente (`RACK_ENV` environment variável) é
657
+ setado para `:production`:
658
+
659
+ ``` ruby
660
+ configure :production do
661
+ ...
662
+ end
663
+ ```
664
+
665
+ Rodando quando o ambiente é setado para `:production` ou `:test`:
666
+
667
+ ``` ruby
668
+ configure :production, :test do
669
+ ...
670
+ end
671
+ ```
672
+
673
+ ## Tratamento de Erros
674
+
675
+ Tratamento de erros rodam dentro do mesmo contexto como rotas e filtros
676
+ before, o que significa que você pega todos os presentes que tem para
677
+ oferecer, como `haml`, `erb`, `halt`, etc.
678
+
679
+ ### Não Encontrado
680
+
681
+ Quando um `Sinatra::NotFound` exception é levantado, ou o código de
682
+ status da reposta é 404, o `not_found` manipulador é invocado:
683
+
684
+ ``` ruby
685
+ not_found do
686
+ 'Isto está longe de ser encontrado'
687
+ end
688
+ ```
689
+
690
+ ### Erro
691
+
692
+ O manipulador `error` é invocado toda a vez que uma exceção é lançada a
693
+ partir de um bloco de rota ou um filtro. O objeto da exceção pode ser
694
+ obtido a partir da variável Rack `sinatra.error`:
695
+
696
+ ``` ruby
697
+ error do
698
+ 'Desculpe, houve um erro desagradável - ' + env['sinatra.error'].name
699
+ end
700
+ ```
701
+
702
+ Erros customizados:
703
+
704
+ ``` ruby
705
+ error MeuErroCustomizado do
706
+ 'Então que aconteceu foi...' + env['sinatra.error'].message
707
+ end
708
+ ```
709
+
710
+ Então, se isso acontecer:
711
+
712
+ ``` ruby
713
+ get '/' do
714
+ raise MeuErroCustomizado, 'alguma coisa ruim'
715
+ end
716
+ ```
717
+
718
+ Você receberá isso:
719
+
720
+ Então que aconteceu foi... alguma coisa ruim
721
+
722
+ Alternativamente, você pode instalar manipulador de erro para um código
723
+ de status:
724
+
725
+ ``` ruby
726
+ error 403 do
727
+ 'Accesso negado'
728
+ end
729
+
730
+ get '/secreto' do
731
+ 403
732
+ end
733
+ ```
734
+
735
+ Ou um range:
736
+
737
+ ``` ruby
738
+ error 400..510 do
739
+ 'Boom'
740
+ end
741
+ ```
742
+
743
+ O Sinatra instala os manipuladores especiais `not_found` e `error`
744
+ quando roda sobre o ambiente de desenvolvimento.
745
+
746
+ ## Mime Types
747
+
748
+ Quando utilizamos `send_file` ou arquivos estáticos você pode ter mime
749
+ types Sinatra não entendidos. Use `mime_type` para registrar eles por
750
+ extensão de arquivos:
751
+
752
+ ``` ruby
753
+ mime_type :foo, 'text/foo'
754
+ ```
755
+
756
+ Você também pode utilizar isto com o helper `content_type`:
757
+
758
+ ``` ruby
759
+ content_type :foo
760
+ ```
761
+
762
+ ## Middleware Rack
763
+
764
+ O Sinatra roda no [Rack](http://rack.rubyforge.org/), uma interface
765
+ padrão mínima para frameworks web em Ruby. Um das capacidades mais
766
+ interessantes do Rack para desenvolver aplicativos é suporte a
767
+ “middleware” – componentes que ficam entre o servidor e sua aplicação
768
+ monitorando e/ou manipulando o request/response do HTTP para prover
769
+ vários tipos de funcionalidades comuns.
770
+
771
+ O Sinatra faz construtores pipelines do middleware Rack facilmente em um
772
+ nível superior utilizando o método `use`:
773
+
774
+ ``` ruby
775
+ require 'sinatra'
776
+ require 'meu_middleware_customizado'
777
+
778
+ use Rack::Lint
779
+ use MeuMiddlewareCustomizado
780
+
781
+ get '/ola' do
782
+ 'Olá mundo'
783
+ end
784
+ ```
785
+
786
+ A semântica de `use` é idêntica aquela definida para a DSL
787
+ [Rack::Builder](http://rack.rubyforge.org/doc/classes/Rack/Builder.html)
788
+ (mais frequentemente utilizada para arquivos rackup). Por exemplo, o
789
+ método `use` aceita múltiplos argumentos/variáveis bem como blocos:
790
+
791
+ ``` ruby
792
+ use Rack::Auth::Basic do |usuario, senha|
793
+ usuario == 'admin' && senha == 'secreto'
794
+ end
795
+ ```
796
+
797
+ O Rack é distribuido com uma variedade de middleware padrões para logs,
798
+ debugs, rotas de URL, autenticação, e manipuladores de sessão. Sinatra
799
+ utilizada muitos desses componentes automaticamente baseando sobre
800
+ configuração, então, tipicamente você não tem `use` explicitamente.
801
+
802
+ ## Testando
803
+
804
+ Testes no Sinatra podem ser escritos utilizando qualquer biblioteca ou
805
+ framework de teste baseados no Rack.
806
+ [Rack::Test](http://gitrdoc.com/brynary/rack-test) é recomendado:
807
+
808
+ ``` ruby
809
+ require 'minha_aplicacao_sinatra'
810
+ require 'rack/test'
811
+
812
+ class MinhaAplicacaoTeste < Test::Unit::TestCase
813
+ include Rack::Test::Methods
814
+
815
+ def app
816
+ Sinatra::Application
817
+ end
818
+
819
+ def meu_test_default
820
+ get '/'
821
+ assert_equal 'Ola Mundo!', last_response.body
822
+ end
823
+
824
+ def teste_com_parametros
825
+ get '/atender', :name => 'Frank'
826
+ assert_equal 'Olá Frank!', last_response.bodymeet
827
+ end
828
+
829
+ def test_com_ambiente_rack
830
+ get '/', {}, 'HTTP_USER_AGENT' => 'Songbird'
831
+ assert_equal "Você está utilizando o Songbird!", last_response.body
832
+ end
833
+ end
834
+ ```
835
+
836
+ NOTA: Os módulos de classe embutidos `Sinatra::Test` e
837
+ `Sinatra::TestHarness` são depreciados na versão 0.9.2.
838
+
839
+ ## Sinatra::Base - Middleware, Bibliotecas e aplicativos modulares
840
+
841
+ Definir sua aplicação em um nível superior de trabalho funciona bem para
842
+ micro aplicativos, mas tem consideráveis incovenientes na construção de
843
+ componentes reutilizáveis como um middleware Rack, metal Rails,
844
+ bibliotecas simples como um componente de servidor, ou mesmo extensões
845
+ Sinatra. A DSL de nível superior polui o espaço do objeto e assume um
846
+ estilo de configuração de micro aplicativos (exemplo: uma simples
847
+ arquivo de aplicação, diretórios `./public` e `./views`, logs, página de
848
+ detalhes de exceção, etc.). É onde o `Sinatra::Base` entra em jogo:
849
+
850
+ ``` ruby
851
+ require 'sinatra/base'
852
+
853
+ class MinhaApp < Sinatra::Base
854
+ set :sessions, true
855
+ set :foo, 'bar'
856
+
857
+ get '/' do
858
+ 'Ola mundo!'
859
+ end
860
+ end
861
+ ```
862
+
863
+ A classe `MinhaApp` é um componente Rack independente que pode agir como
864
+ um middleware Rack, uma aplicação Rack, ou metal Rails. Você pode
865
+ utilizar ou executar esta classe com um arquivo rackup `config.ru`;
866
+ ou, controlar um componente de servidor fornecendo como biblioteca:
867
+
868
+ ``` ruby
869
+ MinhaApp.run! :host => 'localhost', :port => 9090
870
+ ```
871
+
872
+ Os métodos disponíveis para subclasses `Sinatra::Base` são exatamente como
873
+ aqueles disponíveis via a DSL de nível superior. Aplicações de nível
874
+ mais alto podem ser convertidas para componentes `Sinatra::Base` com duas
875
+ modificações:
876
+
877
+ - Seu arquivo deve requerer `sinatra/base` ao invés de `sinatra`;
878
+ outra coisa, todos os métodos DSL do Sinatra são importados para o
879
+ espaço principal.
880
+
881
+ - Coloque as rotas da sua aplicação, manipuladores de erro, filtros e
882
+ opções na subclasse de um `Sinatra::Base`.
883
+
884
+ `Sinatra::Base` é um quadro branco. Muitas opções são desabilitadas por
885
+ padrão, incluindo o servidor embutido. Veja [Opções e
886
+ Configurações](http://sinatra.github.com/configuration.html) para
887
+ detalhes de opções disponíveis e seus comportamentos.
888
+
889
+ SIDEBAR: A DSL de alto nível do Sinatra é implementada utilizando um simples
890
+ sistema de delegação. A classe `Sinatra::Application` – uma subclasse especial
891
+ da `Sinatra::Base` – recebe todos os `:get`, `:put`, `:post`, `:delete`,
892
+ `:before`, `:error`, `:not_found`, `:configure`, e `:set messages` enviados
893
+ para o alto nível. Dê uma olhada no código você mesmo: aqui está o
894
+ [Sinatra::Delegator
895
+ mixin](http://github.com/sinatra/sinatra/blob/ceac46f0bc129a6e994a06100aa854f606fe5992/lib/sinatra/base.rb#L1128)
896
+ sendo [incluido dentro de um espaço
897
+ principal](http://github.com/sinatra/sinatra/blob/ceac46f0bc129a6e994a06100aa854f606fe5992/lib/sinatra/main.rb#L28)
898
+
899
+ ## Linha de Comando
900
+
901
+ Aplicações Sinatra podem ser executadas diretamente:
902
+
903
+ ``` shell
904
+ ruby minhaapp.rb [-h] [-x] [-e AMBIENTE] [-p PORTA] [-o HOST] [-s SERVIDOR]
905
+ ```
906
+
907
+ As opções são:
908
+
909
+ ```
910
+ -h # ajuda
911
+ -p # define a porta (padrão é 4567)
912
+ -o # define o host (padrão é 0.0.0.0)
913
+ -e # define o ambiente (padrão é development)
914
+ -s # especifica o servidor/manipulador rack (padrão é thin)
915
+ -x # ativa o bloqueio (padrão é desligado)
916
+ ```
917
+
918
+ ## A última versão
919
+
920
+ Se você gostaria de utilizar o código da última versão do Sinatra, crie
921
+ um clone local e execute sua aplicação com o diretório `sinatra/lib` no
922
+ `LOAD_PATH`:
923
+
924
+ ``` shell
925
+ cd minhaapp
926
+ git clone git://github.com/sinatra/sinatra.git
927
+ ruby -I sinatra/lib minhaapp.rb
928
+ ```
929
+
930
+ Alternativamente, você pode adicionar o diretório do `sinatra/lib` no
931
+ `LOAD_PATH` do seu aplicativo:
932
+
933
+ ``` ruby
934
+ $LOAD_PATH.unshift File.dirname(__FILE__) + '/sinatra/lib'
935
+ require 'rubygems'
936
+ require 'sinatra'
937
+
938
+ get '/sobre' do
939
+ "Estou rodando a versão" + Sinatra::VERSION
940
+ end
941
+ ```
942
+
943
+ Para atualizar o código do Sinatra no futuro:
944
+
945
+ ``` shell
946
+ cd meuprojeto/sinatra
947
+ git pull
948
+ ```
949
+
950
+ ## Mais
951
+
952
+ - [Website do Projeto](http://www.sinatrarb.com/) - Documentação
953
+ adicional, novidades e links para outros recursos.
954
+
955
+ - [Contribuir](http://www.sinatrarb.com/contributing) - Encontrar um
956
+ bug? Precisa de ajuda? Tem um patch?
957
+
958
+ - [Acompanhar Questões](http://github.com/sinatra/sinatra/issues)
959
+
960
+ - [Twitter](http://twitter.com/sinatra)
961
+
962
+ - [Lista de Email](http://groups.google.com/group/sinatrarb/topics)
963
+
964
+ - [IRC: \#sinatra](irc://chat.freenode.net/#sinatra) em
965
+ [freenode.net](http://freenode.net)