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.

@@ -0,0 +1,791 @@
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 rapidamente aplicações web em Ruby com o mínimo de esforço:
9
+
10
+ ``` ruby
11
+ # minhaapp.rb
12
+ require 'rubygems'
13
+ require 'sinatra'
14
+ get '/' do
15
+ 'Olá Mundo!'
16
+ end
17
+ ```
18
+
19
+ Instale a gem e execute com:
20
+
21
+ ``` shell
22
+ sudo gem install sinatra
23
+ ruby minhaapp.rb
24
+ ```
25
+
26
+ Aceda em: [localhost:4567](http://localhost:4567)
27
+
28
+ ## Rotas
29
+
30
+ No Sinatra, uma rota é um metodo HTTP associado a uma URL correspondente
31
+ padrão. Cada rota é associada a um bloco:
32
+
33
+ ``` ruby
34
+ get '/' do
35
+ .. mostrar algo ..
36
+ end
37
+
38
+ post '/' do
39
+ .. criar algo ..
40
+ end
41
+
42
+ put '/' do
43
+ .. atualizar algo ..
44
+ end
45
+
46
+ delete '/' do
47
+ .. apagar algo ..
48
+ end
49
+ ```
50
+
51
+ Rotas são encontradas na ordem em que são definidas. A primeira rota que
52
+ é encontrada invoca o pedido.
53
+
54
+ Padrões de rota podem incluir parâmetros nomeados, acessíveis através da
55
+ hash `params`:
56
+
57
+ ``` ruby
58
+ get '/ola/:nome' do
59
+ # corresponde a "GET /ola/foo" e "GET /ola/bar"
60
+ # params[:nome] é 'foo' ou 'bar'
61
+ "Olá #{params[:nome]}!"
62
+ end
63
+ ```
64
+
65
+ Pode também aceder a parâmetros nomeados através do bloco de parâmetros:
66
+
67
+ ``` ruby
68
+ get '/ola/:nome' do |n|
69
+ "Olá #{n}!"
70
+ end
71
+ ```
72
+
73
+ Padrões de rota podem também incluir parâmetros splat (asteriscos),
74
+ acessíveis através do array `params[:splat]`.
75
+
76
+ ``` ruby
77
+ get '/diga/*/ao/*' do
78
+ # corresponde a /diga/ola/ao/mundo
79
+ params[:splat] # => ["ola", "mundo"]
80
+ end
81
+
82
+ get '/download/*.*' do
83
+ # corresponde a /download/pasta/do/arquivo.xml
84
+ params[:splat] # => ["pasta/do/arquivo", "xml"]
85
+ end
86
+ ```
87
+
88
+ Rotas correspondem-se com expressões regulares:
89
+
90
+ ``` ruby
91
+ get %r{/ola/([\w]+)} do
92
+ "Olá, #{params[:captures].first}!"
93
+ end
94
+ ```
95
+
96
+ Ou com um bloco de parâmetro:
97
+
98
+ ``` ruby
99
+ get %r{/ola/([\w]+)} do |c|
100
+ "Olá, #{c}!"
101
+ end
102
+ ```
103
+
104
+ Rotas podem incluir uma variedade de condições correspondentes, por
105
+ exemplo, o agente usuário:
106
+
107
+ ``` ruby
108
+ get '/foo', :agent => /Songbird (\d\.\d)[\d\/]*?/ do
109
+ "Você está a utilizar a versão #{params[:agent][0]} do Songbird."
110
+ end
111
+
112
+ get '/foo' do
113
+ # Corresponde a um navegador não Songbird
114
+ end
115
+ ```
116
+
117
+ ## Arquivos estáticos
118
+
119
+ Arquivos estáticos são disponibilizados a partir do directório
120
+ `./public`. Você pode especificar um local diferente através da opção
121
+ `:public_folder`
122
+
123
+ ``` ruby
124
+ set :public_folder, File.dirname(__FILE__) + '/estatico'
125
+ ```
126
+
127
+ Note que o nome do directório público não é incluido no URL. Um arquivo
128
+ `./public/css/style.css` é disponibilizado como
129
+ `http://example.com/css/style.css`.
130
+
131
+ ## Views / Templates
132
+
133
+ Templates presumem-se estar localizados sob o directório `./views`. Para
134
+ utilizar um directório de views diferente:
135
+
136
+ ``` ruby
137
+ set :views, File.dirname(__FILE__) + '/modelo'
138
+ ```
139
+
140
+ Uma coisa importante a ser lembrada é que você sempre tem as referências
141
+ dos templates como símbolos, mesmo se eles estiverem num sub-directório
142
+ (nesse caso utilize `:'subdir/template'`). Métodos de renderização irão
143
+ processar qualquer string passada directamente para elas.
144
+
145
+ ### Haml Templates
146
+
147
+ A gem/biblioteca haml é necessária para renderizar templates HAML:
148
+
149
+ ``` ruby
150
+ # É necessário requerir 'haml' na aplicação.
151
+ require 'haml'
152
+
153
+ get '/' do
154
+ haml :index
155
+ end
156
+ ```
157
+
158
+ Renderiza `./views/index.haml`.
159
+
160
+ [Opções
161
+ Haml](http://haml.info/docs/yardoc/file.HAML_REFERENCE.html#options)
162
+ podem ser definidas globalmente através das configurações do sinatra,
163
+ veja [Opções e
164
+ Configurações](http://www.sinatrarb.com/configuration.html), e substitua
165
+ em uma requisição individual.
166
+
167
+ ``` ruby
168
+ set :haml, {:format => :html5 } # o formato padrão do Haml é :xhtml
169
+
170
+ get '/' do
171
+ haml :index, :haml_options => {:format => :html4 } # substituido
172
+ end
173
+ ```
174
+
175
+ ### Erb Templates
176
+
177
+ ``` ruby
178
+ # É necessário requerir 'erb' na aplicação.
179
+ require 'erb'
180
+
181
+ get '/' do
182
+ erb :index
183
+ end
184
+ ```
185
+
186
+ Renderiza `./views/index.erb`
187
+
188
+ ### Erubis
189
+
190
+ A gem/biblioteca erubis é necessária para renderizar templates erubis:
191
+
192
+ ``` ruby
193
+ # É necessário requerir 'erubis' na aplicação.
194
+ require 'erubis'
195
+
196
+ get '/' do
197
+ erubis :index
198
+ end
199
+ ```
200
+
201
+ Renderiza `./views/index.erubis`
202
+
203
+ ### Builder Templates
204
+
205
+ A gem/biblioteca builder é necessária para renderizar templates builder:
206
+
207
+ ``` ruby
208
+ # É necessário requerir 'builder' na aplicação.
209
+ require 'builder'
210
+
211
+ get '/' do
212
+ content_type 'application/xml', :charset => 'utf-8'
213
+ builder :index
214
+ end
215
+ ```
216
+
217
+ Renderiza `./views/index.builder`.
218
+
219
+ ### Sass Templates
220
+
221
+ A gem/biblioteca sass é necessária para renderizar templates sass:
222
+
223
+ ``` ruby
224
+ # É necessário requerir 'haml' ou 'sass' na aplicação.
225
+ require 'sass'
226
+
227
+ get '/stylesheet.css' do
228
+ content_type 'text/css', :charset => 'utf-8'
229
+ sass :stylesheet
230
+ end
231
+ ```
232
+
233
+ Renderiza `./views/stylesheet.sass`.
234
+
235
+ [Opções
236
+ Sass](http://sass-lang.com/docs/yardoc/file.SASS_REFERENCE.html#options)
237
+ podem ser definidas globalmente através das configurações do sinatra,
238
+ veja [Opções e
239
+ Configurações](http://www.sinatrarb.com/configuration.html), e substitua
240
+ em uma requisição individual.
241
+
242
+ ``` ruby
243
+ set :sass, {:style => :compact } # o estilo padrão do Sass é :nested
244
+
245
+ get '/stylesheet.css' do
246
+ content_type 'text/css', :charset => 'utf-8'
247
+ sass :stylesheet, :style => :expanded # substituido
248
+ end
249
+ ```
250
+
251
+ ### Less Templates
252
+
253
+ A gem/biblioteca less é necessária para renderizar templates Less:
254
+
255
+ ``` ruby
256
+ # É necessário requerir 'less' na aplicação.
257
+ require 'less'
258
+
259
+ get '/stylesheet.css' do
260
+ content_type 'text/css', :charset => 'utf-8'
261
+ less :stylesheet
262
+ end
263
+ ```
264
+
265
+ Renderiza `./views/stylesheet.less`.
266
+
267
+ ### Templates Inline
268
+
269
+ ``` ruby
270
+ get '/' do
271
+ haml '%div.title Olá Mundo'
272
+ end
273
+ ```
274
+
275
+ Renderiza a string, em uma linha, no template.
276
+
277
+ ### Acedendo a Variáveis nos Templates
278
+
279
+ Templates são avaliados dentro do mesmo contexto que os manipuladores de
280
+ rota. Variáveis de instância definidas em rotas manipuladas são
281
+ directamente acedidas por templates:
282
+
283
+ ``` ruby
284
+ get '/:id' do
285
+ @foo = Foo.find(params[:id])
286
+ haml '%h1= @foo.nome'
287
+ end
288
+ ```
289
+
290
+ Ou, especifique um hash explícito para variáveis locais:
291
+
292
+ ``` ruby
293
+ get '/:id' do
294
+ foo = Foo.find(params[:id])
295
+ haml '%h1= foo.nome', :locals => { :foo => foo }
296
+ end
297
+ ```
298
+
299
+ Isso é tipicamente utilizado quando renderizamos templates parciais
300
+ (partials) dentro de outros templates.
301
+
302
+ ### Templates Inline
303
+
304
+ Templates podem ser definidos no final do arquivo fonte(.rb):
305
+
306
+ ``` ruby
307
+ require 'rubygems'
308
+ require 'sinatra'
309
+
310
+ get '/' do
311
+ haml :index
312
+ end
313
+
314
+ __END__
315
+
316
+ @@ layout
317
+ %html
318
+ = yield
319
+
320
+ @@ index
321
+ %div.title Olá Mundo!!!!!
322
+ ```
323
+
324
+ NOTA: Templates inline definidos no arquivo fonte são automaticamente
325
+ carregados pelo sinatra. Digite \`enable :inline\_templates\` se tem
326
+ templates inline no outro arquivo fonte.
327
+
328
+ ### Templates nomeados
329
+
330
+ Templates também podem ser definidos utilizando o método top-level
331
+ `template`:
332
+
333
+ ``` ruby
334
+ template :layout do
335
+ "%html\n =yield\n"
336
+ end
337
+
338
+ template :index do
339
+ '%div.title Olá Mundo!'
340
+ end
341
+
342
+ get '/' do
343
+ haml :index
344
+ end
345
+ ```
346
+
347
+ Se existir um template com nome “layout”, ele será utilizado sempre que
348
+ um template for renderizado. Pode desactivar layouts usando
349
+ `:layout => false`.
350
+
351
+ ``` ruby
352
+ get '/' do
353
+ haml :index, :layout => !request.xhr?
354
+ end
355
+ ```
356
+
357
+ ## Helpers
358
+
359
+ Use o método de alto nível `helpers` para definir métodos auxiliares
360
+ para utilizar em manipuladores de rotas e modelos:
361
+
362
+ ``` ruby
363
+ helpers do
364
+ def bar(nome)
365
+ "#{nome}bar"
366
+ end
367
+ end
368
+
369
+ get '/:nome' do
370
+ bar(params[:nome])
371
+ end
372
+ ```
373
+
374
+ ## Filtros
375
+
376
+ Filtros Before são avaliados antes de cada requisição dentro do contexto
377
+ da requisição e podem modificar a requisição e a reposta. Variáveis de
378
+ instância definidas nos filtros são acedidas através de rotas e
379
+ templates:
380
+
381
+ ``` ruby
382
+ before do
383
+ @nota = 'Olá!'
384
+ request.path_info = '/foo/bar/baz'
385
+ end
386
+
387
+ get '/foo/*' do
388
+ @nota #=> 'Olá!'
389
+ params[:splat] #=> 'bar/baz'
390
+ end
391
+ ```
392
+
393
+ Filtros After são avaliados após cada requisição dentro do contexto da
394
+ requisição e também podem modificar o pedido e a resposta. Variáveis de
395
+ instância definidas nos filtros before e rotas são acedidas através dos
396
+ filtros after:
397
+
398
+ ``` ruby
399
+ after do
400
+ puts response.status
401
+ end
402
+ ```
403
+
404
+ Filtros opcionalmente têm um padrão, fazendo com que sejam avaliados
405
+ somente se o caminho do pedido coincidir com esse padrão:
406
+
407
+ ``` ruby
408
+ before '/protected/*' do
409
+ autenticar!
410
+ end
411
+
412
+ after '/create/:slug' do |slug|
413
+ session[:last_slug] = slug
414
+ end
415
+ ```
416
+
417
+ ## Halting
418
+
419
+ Para parar imediatamente uma requisição dentro de um filtro ou rota
420
+ utilize:
421
+
422
+ ``` ruby
423
+ halt
424
+ ```
425
+
426
+ Pode também especificar o status ao parar…
427
+
428
+ ``` ruby
429
+ halt 410
430
+ ```
431
+
432
+ Ou com um corpo de texto…
433
+
434
+ ``` ruby
435
+ halt 'isto será o corpo de texto'
436
+ ```
437
+
438
+ Ou também…
439
+
440
+ ``` ruby
441
+ halt 401, 'vamos embora!'
442
+ ```
443
+
444
+ Com cabeçalhos…
445
+
446
+ ``` ruby
447
+ halt 402, {'Content-Type' => 'text/plain'}, 'revanche'
448
+ ```
449
+
450
+ ## Passing
451
+
452
+ Dentro de uma rota, pode passar para a próxima rota correspondente
453
+ usando `pass`:
454
+
455
+ ``` ruby
456
+ get '/adivinhar/:quem' do
457
+ pass unless params[:quem] == 'Frank'
458
+ 'Apanhaste-me!'
459
+ end
460
+
461
+ get '/adivinhar/*' do
462
+ 'Falhaste!'
463
+ end
464
+ ```
465
+
466
+ O bloqueio da rota é imediatamente encerrado e o controle continua com a
467
+ próxima rota de parâmetro. Se o parâmetro da rota não for encontrado, um
468
+ 404 é retornado.
469
+
470
+ ## Configuração
471
+
472
+ Correndo uma vez, na inicialização, em qualquer ambiente:
473
+
474
+ ``` ruby
475
+ configure do
476
+ ...
477
+ end
478
+ ```
479
+
480
+ Correndo somente quando o ambiente (`RACK_ENV` environment variável) é
481
+ definido para `:production`:
482
+
483
+ ``` ruby
484
+ configure :production do
485
+ ...
486
+ end
487
+ ```
488
+
489
+ Correndo quando o ambiente é definido para `:production` ou `:test`:
490
+
491
+ ``` ruby
492
+ configure :production, :test do
493
+ ...
494
+ end
495
+ ```
496
+
497
+ ## Lidar com Erros
498
+
499
+ Lida-se com erros no mesmo contexto das rotas e filtros before, o que
500
+ signifca que `haml`, `erb`, etc, estão disponíveis.
501
+
502
+ ### Não Encontrado
503
+
504
+ Quando um `Sinatra::NotFound` exception é levantado, ou o código de
505
+ status da reposta é 404, o manipulador `not_found` é invocado:
506
+
507
+ ``` ruby
508
+ not_found do
509
+ 'Isto está longe de ser encontrado'
510
+ end
511
+ ```
512
+
513
+ ### Erro
514
+
515
+ O manipulador `error` é invocado sempre que uma exceção é lançada a
516
+ partir de um bloco de rota ou um filtro. O objecto da exceção pode ser
517
+ obtido a partir da variável Rack `sinatra.error`:
518
+
519
+ ``` ruby
520
+ error do
521
+ 'Peço desculpa, houve um erro desagradável - ' + env['sinatra.error'].name
522
+ end
523
+ ```
524
+
525
+ Erros personalizados:
526
+
527
+ ``` ruby
528
+ error MeuErroPersonalizado do
529
+ 'O que aconteceu foi...' + env['sinatra.error'].message
530
+ end
531
+ ```
532
+
533
+ Então, se isso acontecer:
534
+
535
+ ``` ruby
536
+ get '/' do
537
+ raise MeuErroPersonalizado, 'alguma coisa desagradável'
538
+ end
539
+ ```
540
+
541
+ O resultado será:
542
+
543
+ ```
544
+ O que aconteceu foi...alguma coisa desagradável
545
+ ```
546
+
547
+ Alternativamente, pode definir um manipulador de erro para um código de
548
+ status:
549
+
550
+ ``` ruby
551
+ error 403 do
552
+ 'Accesso negado'
553
+ end
554
+
555
+ get '/secreto' do
556
+ 403
557
+ end
558
+ ```
559
+
560
+ Ou um range (alcance):
561
+
562
+ ``` ruby
563
+ error 400..510 do
564
+ 'Boom'
565
+ end
566
+ ```
567
+
568
+ O Sinatra define os manipuladores especiais `not_found` e `error` quando
569
+ corre no ambiente de desenvolvimento.
570
+
571
+ ## Mime Types
572
+
573
+ Quando utilizamos `send_file` ou arquivos estáticos pode ter mime types
574
+ Sinatra não entendidos. Use `mime_type` para os registar por extensão de
575
+ arquivos:
576
+
577
+ ``` ruby
578
+ mime_type :foo, 'text/foo'
579
+ ```
580
+
581
+ Pode também utilizar isto com o helper `content_type`:
582
+
583
+ ``` ruby
584
+ content_type :foo
585
+ ```
586
+
587
+ ## Middleware Rack
588
+
589
+ O Sinatra corre no [Rack](http://rack.rubyforge.org/), uma interface
590
+ padrão mínima para frameworks web em Ruby. Uma das capacidades mais
591
+ interessantes do Rack, para desenvolver aplicações, é o suporte de
592
+ “middleware” – componentes que residem entre o servidor e a aplicação,
593
+ monitorizando e/ou manipulando o pedido/resposta (request/response) HTTP
594
+ para providenciar varios tipos de funcionalidades comuns.
595
+
596
+ O Sinatra torna a construção de pipelines do middleware Rack fácil a um
597
+ nível superior utilizando o método `use`:
598
+
599
+ ``` ruby
600
+ require 'sinatra'
601
+ require 'meu_middleware_personalizado'
602
+
603
+ use Rack::Lint
604
+ use MeuMiddlewarePersonalizado
605
+
606
+ get '/ola' do
607
+ 'Olá mundo'
608
+ end
609
+ ```
610
+
611
+ A semântica de `use` é idêntica aquela definida para a DSL
612
+ [Rack::Builder](http://rack.rubyforge.org/doc/classes/Rack/Builder.html)
613
+ (mais frequentemente utilizada para arquivos rackup). Por exemplo, o
614
+ método `use` aceita múltiplos argumentos/variáveis, bem como blocos:
615
+
616
+ ``` ruby
617
+ use Rack::Auth::Basic do |utilizador, senha|
618
+ utilizador == 'admin' && senha == 'secreto'
619
+ end
620
+ ```
621
+
622
+ O Rack é distribuido com uma variedade de middleware padrões para logs,
623
+ debugs, rotas de URL, autenticação, e manipuladores de sessão.Sinatra
624
+ utiliza muitos desses componentes automaticamente dependendo da
625
+ configuração, por isso, tipicamente nao é necessário utilizar `use`
626
+ explicitamente.
627
+
628
+ ## Testando
629
+
630
+ Testes no Sinatra podem ser escritos utilizando qualquer biblioteca ou
631
+ framework de teste baseados no Rack.
632
+ [Rack::Test](http://gitrdoc.com/brynary/rack-test) é recomendado:
633
+
634
+ ``` ruby
635
+ require 'minha_aplicacao_sinatra'
636
+ require 'rack/test'
637
+
638
+ class MinhaAplicacaoTeste < Test::Unit::TestCase
639
+ include Rack::Test::Methods
640
+
641
+ def app
642
+ Sinatra::Application
643
+ end
644
+
645
+ def meu_test_default
646
+ get '/'
647
+ assert_equal 'Ola Mundo!', last_response.body
648
+ end
649
+
650
+ def teste_com_parametros
651
+ get '/atender', :name => 'Frank'
652
+ assert_equal 'Olá Frank!', last_response.bodymeet
653
+ end
654
+
655
+ def test_com_ambiente_rack
656
+ get '/', {}, 'HTTP_USER_AGENT' => 'Songbird'
657
+ assert_equal "Você está utilizando o Songbird!", last_response.body
658
+ end
659
+ end
660
+ ```
661
+
662
+ NOTA: Os módulos de classe embutidos `Sinatra::Test` e
663
+ `Sinatra::TestHarness` são depreciados na versão 0.9.2.
664
+
665
+ ## Sinatra::Base - Middleware, Bibliotecas e aplicativos modulares
666
+
667
+ Definir sua aplicação a um nível superior de trabalho funciona bem para
668
+ micro aplicativos, mas tem consideráveis incovenientes na construção de
669
+ componentes reutilizáveis como um middleware Rack, metal Rails,
670
+ bibliotecas simples como um componente de servidor, ou mesmo extensões
671
+ Sinatra. A DSL de nível superior polui o espaço do objeto e assume um
672
+ estilo de configuração de micro aplicativos (exemplo: um simples arquivo
673
+ de aplicação, directórios `./public` e `./views`, logs, página de detalhes
674
+ de excepção, etc.). É onde o Sinatra::Base entra em jogo:
675
+
676
+ ``` ruby
677
+ require 'sinatra/base'
678
+
679
+ class MinhaApp < Sinatra::Base
680
+ set :sessions, true
681
+ set :foo, 'bar'
682
+
683
+ get '/' do
684
+ 'Olá mundo!'
685
+ end
686
+ end
687
+ ```
688
+
689
+ A classe MinhaApp é um componente Rack independente que pode utilizar
690
+ como um middleware Rack, uma aplicação Rack, ou metal Rails. Pode
691
+ utilizar ou executar esta classe com um arquivo rackup `config.ru`;
692
+ ou, controlar um componente de servidor fornecendo como biblioteca:
693
+
694
+ ``` ruby
695
+ MinhaApp.run! :host => 'localhost', :port => 9090
696
+ ```
697
+
698
+ Os métodos disponíveis para subclasses `Sinatra::Base` são exatamente como
699
+ aqueles disponíveis via a DSL de nível superior. Aplicações de nível
700
+ mais alto podem ser convertidas para componentes `Sinatra::Base` com duas
701
+ modificações:
702
+
703
+ - Seu arquivo deve requerer `sinatra/base` ao invés de `sinatra`;
704
+ outra coisa, todos os métodos DSL do Sinatra são importados para o
705
+ espaço principal.
706
+
707
+ - Coloque as rotas da sua aplicação, manipuladores de erro, filtros e
708
+ opções na subclasse de um `Sinatra::Base`.
709
+
710
+ `Sinatra::Base` é um quadro branco. Muitas opções são desactivadas por
711
+ padrão, incluindo o servidor embutido. Veja [Opções e
712
+ Configurações](http://sinatra.github.com/configuration.html) para
713
+ detalhes de opções disponíveis e seus comportamentos.
714
+
715
+ SIDEBAR: A DSL de alto nível do Sinatra é implementada utilizando um simples
716
+ sistema de delegação. A classe `Sinatra::Application` – uma subclasse especial
717
+ da `Sinatra::Base` – recebe todos os `:get`, `:put`, `:post`, `:delete`,
718
+ `:before`, `:error`, `:not_found`, `:configure`, e `:set` messages enviados
719
+ para o alto nível. Dê você mesmo uma vista de olhos ao código: aqui está o
720
+ [Sinatra::Delegator
721
+ mixin](http://github.com/sinatra/sinatra/blob/ceac46f0bc129a6e994a06100aa854f606fe5992/lib/sinatra/base.rb#L1128)
722
+ sendo [incluido dentro de um espaço
723
+ principal](http://github.com/sinatra/sinatra/blob/ceac46f0bc129a6e994a06100aa854f606fe5992/lib/sinatra/main.rb#L28)
724
+
725
+ ## Linha de Comandos
726
+
727
+ As aplicações Sinatra podem ser executadas directamente:
728
+
729
+ ``` shell
730
+ ruby minhaapp.rb [-h] [-x] [-e AMBIENTE] [-p PORTA] [-o HOST] [-s SERVIDOR]
731
+ ```
732
+
733
+ As opções são:
734
+
735
+ ```
736
+ -h # ajuda
737
+ -p # define a porta (padrão é 4567)
738
+ -o # define o host (padrão é 0.0.0.0)
739
+ -e # define o ambiente (padrão é development)
740
+ -s # especifica o servidor/manipulador rack (padrão é thin)
741
+ -x # activa o bloqueio (padrão é desligado)
742
+ ```
743
+
744
+ ## A última versão
745
+
746
+ Se gostaria de utilizar o código da última versão do Sinatra, crie um
747
+ clone local e execute sua aplicação com o directório `sinatra/lib` no
748
+ `LOAD_PATH`:
749
+
750
+ ``` shell
751
+ cd minhaapp
752
+ git clone git://github.com/sinatra/sinatra.git
753
+ ruby -I sinatra/lib minhaapp.rb
754
+ ```
755
+
756
+ Alternativamente, pode adicionar o directório do `sinatra/lib` no
757
+ `LOAD_PATH` do seu aplicativo:
758
+
759
+ ``` ruby
760
+ $LOAD_PATH.unshift File.dirname(__FILE__) + '/sinatra/lib'
761
+ require 'rubygems'
762
+ require 'sinatra'
763
+
764
+ get '/sobre' do
765
+ "Estou correndo a versão" + Sinatra::VERSION
766
+ end
767
+ ```
768
+
769
+ Para actualizar o código do Sinatra no futuro:
770
+
771
+ ``` shell
772
+ cd meuprojeto/sinatra
773
+ git pull
774
+ ```
775
+
776
+ ## Mais
777
+
778
+ - [Website do Projeto](http://www.sinatrarb.com/) - Documentação
779
+ adicional, novidades e links para outros recursos.
780
+
781
+ - [Contribuir](http://www.sinatrarb.com/contributing) - Encontrou um
782
+ bug? Precisa de ajuda? Tem um patch?
783
+
784
+ - [Acompanhar Questões](http://github.com/sinatra/sinatra/issues)
785
+
786
+ - [Twitter](http://twitter.com/sinatra)
787
+
788
+ - [Lista de Email](http://groups.google.com/group/sinatrarb/topics)
789
+
790
+ - [IRC: \#sinatra](irc://chat.freenode.net/#sinatra) em
791
+ [freenode.net](http://freenode.net)