sinatra 1.4.0.c → 1.4.0.d

Sign up to get free protection for your applications and to get access to all the features.

Potentially problematic release.


This version of sinatra might be problematic. Click here for more details.

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