diff --git a/README.md b/README.md
index b88082aa..7417d7c0 100644
--- a/README.md
+++ b/README.md
@@ -391,9 +391,7 @@ Available Options:
directory. To use a different views directory:
-```ruby
- set :views, settings.root + '/templates'
-```
+
set :views, settings.root + '/templates'
One important thing to remember is that you always have to reference
@@ -419,15 +417,15 @@ to use (and to be thread-safe), you should simply require it first:
Dependency |
- [haml](http://haml.info/) |
+ haml |
File Extension |
- .haml |
+ .haml |
Example |
- haml :index, :format => :html5 |
+ haml :index, :format => :html5 |
@@ -436,97 +434,170 @@ to use (and to be thread-safe), you should simply require it first:
Dependency |
- [erubis](http://www.kuwata-lab.com/erubis/) or erb (included in Ruby) |
+
+ erubis
+ or erb (included in Ruby)
+ |
File Extensions |
- .erb, .rhtml or .erubis (Erubis only) |
+ .erb , .rhtml or .erubis (Erubis only) |
Example |
- erb :index |
+ erb :index |
#### Builder Templates
-```ruby
- Dependency [builder](http://builder.rubyforge.org/)
- File Extension .builder
- Example builder { |xml| xml.em "hi" }
-```
+
+
+ Dependency |
+
+ builder
+ |
+
+
+ File Extension |
+ .builder |
+
+
+ Example |
+ builder { |xml| xml.em "hi" } |
+
+
It also takes a block for inline templates (see example).
#### Nokogiri Templates
-```ruby
- Dependency [nokogiri](http://nokogiri.org/)
- File Extension .nokogiri
- Example nokogiri { |xml| xml.em "hi" }
-```
+
+
+ Dependency |
+ nokogiri |
+
+
+ File Extension |
+ .nokogiri |
+
+
+ Example |
+ nokogiri { |xml| xml.e | m "hi" }
+
+
It also takes a block for inline templates (see example).
#### Sass Templates
-```ruby
- Dependency [sass](http://sass-lang.com/)
- File Extension .sass
- Example sass :stylesheet, :style => :expanded
-```
+
+
+ Dependency |
+ sass |
+
+
+ File Extension |
+ .sass |
+
+
+ Example |
+ sass :stylesheet, :style => :expanded |
+
+
#### SCSS Templates
-```ruby
- Dependency [sass](http://sass-lang.com/)
- File Extension .scss
- Example scss :stylesheet, :style => :expanded
-```
+
+
+ Dependency |
+ sass |
+
+
+ File Extension |
+ .scss |
+
+
+ Example |
+ scss :stylesheet, :style => :expanded |
+
+
#### Less Templates
-```ruby
- Dependency [less](http://www.lesscss.org/)
- File Extension .less
- Example less :stylesheet
-```
+
+
+ Dependency |
+ less |
+
+
+ File Extension |
+ .less |
+
+
+ Example |
+ less :stylesheet |
+
+
#### Liquid Templates
-```ruby
- Dependency [liquid](http://www.liquidmarkup.org/)
- File Extension .liquid
- Example liquid :index, :locals => { :key => 'value' }
-```
+
+
+ Dependency |
+ liquid |
+
+
+ File Extension |
+ .liquid |
+
+
+ Example |
+ liquid :index, :locals => { :key => 'value' } |
+
+
Since you cannot call Ruby methods (except for `yield`) from a Liquid
template, you almost always want to pass locals to it.
#### Markdown Templates
-```ruby
- Dependency [rdiscount](https://github.com/rtomayko/rdiscount),
- [redcarpet](https://github.com/vmg/redcarpet),
- [bluecloth](http://deveiate.org/projects/BlueCloth),
- [kramdown](http://kramdown.rubyforge.org/) *or*
- [maruku](http://maruku.rubyforge.org/)
- File Extensions .markdown, .mkd and .md
- Example markdown :index, :layout_engine => :erb
-```
+
+
+ Dependency |
+
+
+ |
+
+
+ File Extensions |
+ .markdown , .mkd and .md |
+
+
+ Example |
+ markdown :index, :layout_engine => :erb |
+
+
+
It is not possible to call methods from markdown, nor to pass locals to it.
You therefore will usually use it in combination with another rendering
engine:
```ruby
-erb :overview, :locals => { :text => markdown(:introduction) }
+ erb :overview, :locals => { :text => markdown(:introduction) }
```
Note that you may also call the `markdown` method from within other templates:
```ruby
-%h1 Hello From Haml!
-%p= markdown(:greetings)
+ %h1 Hello From Haml!
+ %p= markdown(:greetings)
```
Since you cannot call Ruby from Markdown, you cannot use layouts written in
@@ -535,24 +606,34 @@ template than for the layout by passing the `:layout_engine` option.
#### Textile Templates
-```ruby
- Dependency [RedCloth](http://redcloth.org/)
- File Extension .textile
- Example textile :index, :layout_engine => :erb
-```
+
+
+ Dependency |
+ RedCloth |
+
+
+ File Extension |
+ .textile |
+
+
+ Example |
+ textile :index, :layout_engine => :erb |
+
+
+
It is not possible to call methods from textile, nor to pass locals to it. You
therefore will usually use it in combination with another rendering engine:
```ruby
-erb :overview, :locals => { :text => textile(:introduction) }
+ erb :overview, :locals => { :text => textile(:introduction) }
```
Note that you may also call the `textile` method from within other templates:
```ruby
-%h1 Hello From Haml!
-%p= textile(:greetings)
+ %h1 Hello From Haml!
+ %p= textile(:greetings)
```
Since you cannot call Ruby from Textile, you cannot use layouts written in
@@ -561,24 +642,33 @@ template than for the layout by passing the `:layout_engine` option.
#### RDoc Templates
-```ruby
- Dependency [rdoc](http://rdoc.rubyforge.org/)
- File Extension .rdoc
- Example rdoc :README, :layout_engine => :erb
-```
+
+
+ Dependency |
+ RDoc |
+
+
+ File Extension |
+ .rdoc |
+
+
+ Example |
+ rdoc :README, :layout_engine => :erb |
+
+
It is not possible to call methods from rdoc, nor to pass locals to it. You
therefore will usually use it in combination with another rendering engine:
```ruby
-erb :overview, :locals => { :text => rdoc(:introduction) }
+ erb :overview, :locals => { :text => rdoc(:introduction) }
```
Note that you may also call the `rdoc` method from within other templates:
```ruby
-%h1 Hello From Haml!
-%p= rdoc(:greetings)
+ %h1 Hello From Haml!
+ %p= rdoc(:greetings)
```
Since you cannot call Ruby from RDoc, you cannot use layouts written in
@@ -587,61 +677,106 @@ template than for the layout by passing the `:layout_engine` option.
#### Radius Templates
-```ruby
- Dependency [radius](http://radius.rubyforge.org/)
- File Extension .radius
- Example radius :index, :locals => { :key => 'value' }
-```
+
+
+ Dependency |
+ Radius |
+
+
+ File Extension |
+ .radius |
+
+
+ Example |
+ radius :index, :locals => { :key => 'value' } |
+
+
Since you cannot call Ruby methods directly from a Radius template, you almost
always want to pass locals to it.
#### Markaby Templates
-```ruby
- Dependency [markaby](http://markaby.github.com/)
- File Extension .mab
- Example markaby { h1 "Welcome!" }
-```
+
+
+ Dependency |
+ Markaby |
+
+
+ File Extension |
+ .mab |
+
+
+ Example |
+ markaby { h1 "Welcome!" } |
+
+
It also takes a block for inline templates (see example).
#### RABL Templates
-```ruby
- Dependency [rabl](https://github.com/nesquena/rabl)
- File Extension .rabl
- Example rabl :index
-```
+
+
+ Dependency |
+ Rabl |
+
+
+ File Extension |
+ .rabl |
+
+
+ Example |
+ rabl :index |
+
+
#### Slim Templates
-```ruby
- Dependency [slim](http://slim-lang.com/)
- File Extension .slim
- Example slim :index
-```
+
+
+ Dependency |
+ Slim Lang |
+
+
+ File Extension |
+ .slim |
+
+
+ Example |
+ slim :index |
+
+
#### Creole Templates
-```ruby
- Dependency [creole](https://github.com/minad/creole)
- File Extension .creole
- Example creole :wiki, :layout_engine => :erb
-```
+
+
+ Dependency |
+ Creole |
+
+
+ File Extension |
+ .creole |
+
+
+ Example |
+ creole :wiki, :layout_engine => :erb |
+
+
It is not possible to call methods from creole, nor to pass locals to it. You
therefore will usually use it in combination with another rendering engine:
```ruby
-erb :overview, :locals => { :text => creole(:introduction) }
+ erb :overview, :locals => { :text => creole(:introduction) }
```
Note that you may also call the `creole` method from within other templates:
```ruby
-%h1 Hello From Haml!
-%p= creole(:greetings)
+ %h1 Hello From Haml!
+ %p= creole(:greetings)
```
Since you cannot call Ruby from Creole, you cannot use layouts written in
@@ -650,55 +785,93 @@ template than for the layout by passing the `:layout_engine` option.
#### CoffeeScript Templates
-```ruby
- Dependency [coffee-script][coffee] and a [way to execute javascript][execjs]
- File Extension .coffee
- Example:: coffee :index
-```
-[coffee]: https://github.com/josh/ruby-coffee-script "Ruby Coffee Script"
-[execjs]: https://github.com/sstephenson/execjs/blob/master/README.md#readme "ExecJS Readme"
+
#### Yajl Templates
-```ruby
- Dependency [yajl-ruby](https://github.com/brianmario/yajl-ruby)
- File Extension .yajl
- Example yajl :index,
- :locals => { :key => 'qux' },
- :callback => 'present',
- :variable => 'resource'
-```
+
+
+ Dependency |
+ yajl-ruby |
+
+
+ File Extension |
+ .yajl |
+
+
+ Example |
+
+
+ yajl :index,
+ :locals => { :key => 'qux' },
+ :callback => 'present',
+ :variable => 'resource'
+
+ |
+
+
+
The template source is evaluated as a Ruby string, and the
-resulting json variable is converted #to_json.
+resulting json variable is converted using `#to_json`.
```ruby
-json = { :foo => 'bar' }
-json[:baz] = key
+ json = { :foo => 'bar' }
+ json[:baz] = key
```
The `:callback` and `:variable` options can be used to decorate the rendered object.
```ruby
-var resource = {"foo":"bar","baz":"qux"}; present(resource);
+ var resource = {"foo":"bar","baz":"qux"}; present(resource);
```
#### WLang Templates
-```ruby
- Dependency [wlang](https://github.com/blambeau/wlang/)
- File Extension .wlang
- Example wlang :index, :locals => { :key => 'value' }
-```
+
+
+ Dependency |
+ wlang |
+
+
+ File Extension |
+ .wlang |
+
+
+ Example |
+ wlang :index, :locals => { :key => 'value' } |
+
+
+
Since calling ruby methods is not idiomatic in wlang, you almost always want to pass locals
to it. Layouts written in wlang and `yield` are supported, though.
#### Embedded Templates
```ruby
-get '/' do
- haml '%div.title Hello World'
-end
+ get '/' do
+ haml '%div.title Hello World'
+ end
```
Renders the embedded template string.
@@ -709,19 +882,19 @@ Templates are evaluated within the same context as route handlers. Instance
variables set in route handlers are directly accessible by templates:
```ruby
-get '/:id' do
- @foo = Foo.find(params[:id])
- haml '%h1= @foo.name'
-end
+ get '/:id' do
+ @foo = Foo.find(params[:id])
+ haml '%h1= @foo.name'
+ end
```
Or, specify an explicit Hash of local variables:
```ruby
-get '/:id' do
- foo = Foo.find(params[:id])
- haml '%h1= bar.name', :locals => { :bar => foo }
-end
+ get '/:id' do
+ foo = Foo.find(params[:id])
+ haml '%h1= bar.name', :locals => { :bar => foo }
+ end
```
This is typically used when rendering templates as partials from within
@@ -732,20 +905,20 @@ other templates.
Templates may be defined at the end of the source file:
```ruby
-require 'sinatra'
+ require 'sinatra'
-get '/' do
- haml :index
-end
+ get '/' do
+ haml :index
+ end
-__END__
+ __END__
-@@ layout
-%html
- = yield
+ @@ layout
+ %html
+ = yield
-@@ index
-%div.title Hello world.
+ @@ index
+ %div.title Hello world.
```
NOTE: Inline templates defined in the source file that requires sinatra are
@@ -757,17 +930,17 @@ have inline templates in other source files.
Templates may also be defined using the top-level `template` method:
```ruby
-template :layout do
- "%html\n =yield\n"
-end
+ template :layout do
+ "%html\n =yield\n"
+ end
-template :index do
- '%div.title Hello World!'
-end
+ template :index do
+ '%div.title Hello World!'
+ end
-get '/' do
- haml :index
-end
+ get '/' do
+ haml :index
+ end
```
If a template named "layout" exists, it will be used each time a template
@@ -776,9 +949,9 @@ is rendered. You can individually disable layouts by passing
`set :haml, :layout => false`:
```ruby
-get '/' do
- haml :index, :layout => !request.xhr?
-end
+ get '/' do
+ haml :index, :layout => !request.xhr?
+ end
```
### Associating File Extensions
@@ -788,7 +961,7 @@ To associate a file extension with a template engine, use
`tt` for Textile templates, you can do the following:
```ruby
-Tilt.register :tt, Tilt[:textile]
+ Tilt.register :tt, Tilt[:textile]
```
### Adding Your Own Template Engine
@@ -796,15 +969,15 @@ Tilt.register :tt, Tilt[:textile]
First, register your engine with Tilt, then create a rendering method:
```ruby
-Tilt.register :myat, MyAwesomeTemplateEngine
+ Tilt.register :myat, MyAwesomeTemplateEngine
-helpers do
- def myat(*args) render(:myat, *args) end
-end
+ helpers do
+ def myat(*args) render(:myat, *args) end
+ end
-get '/' do
- myat :index
-end
+ get '/' do
+ myat :index
+ end
```
Renders `./views/index.myat`. See https://github.com/rtomayko/tilt to
@@ -817,15 +990,15 @@ context as the routes will be and can modify the request and response. Instance
variables set in filters are accessible by routes and templates:
```ruby
-before do
- @note = 'Hi!'
- request.path_info = '/foo/bar/baz'
-end
+ before do
+ @note = 'Hi!'
+ request.path_info = '/foo/bar/baz'
+ end
-get '/foo/*' do
- @note #=> 'Hi!'
- params[:splat] #=> 'bar/baz'
-end
+ get '/foo/*' do
+ @note #=> 'Hi!'
+ params[:splat] #=> 'bar/baz'
+ end
```
After filters are evaluated after each request within the same context and can
@@ -833,9 +1006,9 @@ also modify the request and response. Instance variables set in before filters
and routes are accessible by after filters:
```ruby
-after do
- puts response.status
-end
+ after do
+ puts response.status
+ end
```
Note: Unless you use the `body` method rather than just returning a String from
@@ -846,25 +1019,25 @@ Filters optionally take a pattern, causing them to be evaluated only if the
request path matches that pattern:
```ruby
-before '/protected/*' do
- authenticate!
-end
+ before '/protected/*' do
+ authenticate!
+ end
-after '/create/:slug' do |slug|
- session[:last_slug] = slug
-end
+ after '/create/:slug' do |slug|
+ session[:last_slug] = slug
+ end
```
Like routes, filters also take conditions:
```ruby
-before :agent => /Songbird/ do
- # ...
-end
+ before :agent => /Songbird/ do
+ # ...
+ end
-after '/blog/*', :host_name => 'example.com' do
- # ...
-end
+ after '/blog/*', :host_name => 'example.com' do
+ # ...
+ end
```
## Helpers
@@ -873,29 +1046,29 @@ Use the top-level `helpers` method to define helper methods for use in
route handlers and templates:
```ruby
-helpers do
- def bar(name)
- "#{name}bar"
- end
-end
+ helpers do
+ def bar(name)
+ "#{name}bar"
+ end
+ end
-get '/:name' do
- bar(params[:name])
-end
+ get '/:name' do
+ bar(params[:name])
+ end
```
Alternatively, helper methods can be separately defined in a module:
```ruby
-module FooUtils
- def foo(name) "#{name}foo" end
-end
+ module FooUtils
+ def foo(name) "#{name}foo" end
+ end
-module BarUtils
- def bar(name) "#{name}bar" end
-end
+ module BarUtils
+ def bar(name) "#{name}bar" end
+ end
-helpers FooUtils, BarUtils
+ helpers FooUtils, BarUtils
```
The effect is the same as including the modules in the application class.
@@ -906,15 +1079,15 @@ A session is used to keep state during requests. If activated, you have one
session hash per user session:
```ruby
-enable :sessions
+ enable :sessions
-get '/' do
- "value = " << session[:value].inspect
-end
+ get '/' do
+ "value = " << session[:value].inspect
+ end
-get '/:value' do
- session[:value] = params[:value]
-end
+ get '/:value' do
+ session[:value] = params[:value]
+ end
```
Note that `enable :sessions` actually stores all data in a cookie. This
@@ -924,15 +1097,15 @@ do so, do **not** call `enable :sessions`, but instead pull in your
middleware of choice as you would any other middleware:
```ruby
-use Rack::Session::Pool, :expire_after => 2592000
+ use Rack::Session::Pool, :expire_after => 2592000
-get '/' do
- "value = " << session[:value].inspect
-end
+ get '/' do
+ "value = " << session[:value].inspect
+ end
-get '/:value' do
- session[:value] = params[:value]
-end
+ get '/:value' do
+ session[:value] = params[:value]
+ end
```
To improve security, the session data in the cookie is signed with a session
@@ -941,14 +1114,14 @@ secret will change with every start of your application, you might want to
set the secret yourself, so all your application instances share it:
```ruby
-set :session_secret, 'super secret'
+ set :session_secret, 'super secret'
```
If you want to configure it further, you may also store a hash with options in
the `sessions` setting:
```ruby
-set :sessions, :domain => 'foo.com'
+ set :sessions, :domain => 'foo.com'
```
### Halting
@@ -956,37 +1129,37 @@ set :sessions, :domain => 'foo.com'
To immediately stop a request within a filter or route use:
```ruby
-halt
+ halt
```
You can also specify the status when halting:
```ruby
-halt 410
+ halt 410
```
Or the body:
```ruby
-halt 'this will be the body'
+ halt 'this will be the body'
```
Or both:
```ruby
-halt 401, 'go away!'
+ halt 401, 'go away!'
```
With headers:
```ruby
-halt 402, {'Content-Type' => 'text/plain'}, 'revenge'
+ halt 402, {'Content-Type' => 'text/plain'}, 'revenge'
```
It is of course possible to combine a template with `halt`:
```ruby
-halt erb(:error)
+ halt erb(:error)
```
### Passing
@@ -994,14 +1167,14 @@ halt erb(:error)
A route can punt processing to the next matching route using `pass`:
```ruby
-get '/guess/:who' do
- pass unless params[:who] == 'Frank'
- 'You got me!'
-end
+ get '/guess/:who' do
+ pass unless params[:who] == 'Frank'
+ 'You got me!'
+ end
-get '/guess/*' do
- 'You missed!'
-end
+ get '/guess/*' do
+ 'You missed!'
+ end
```
The route block is immediately exited and control continues with the next
@@ -1013,14 +1186,14 @@ Sometimes `pass` is not what you want, instead you would like to get the result
of calling another route. Simply use `call` to achieve this:
```ruby
-get '/foo' do
- status, headers, body = call env.merge("PATH_INFO" => '/bar')
- [status, headers, body.map(&:upcase)]
-end
+ get '/foo' do
+ status, headers, body = call env.merge("PATH_INFO" => '/bar')
+ [status, headers, body.map(&:upcase)]
+ end
-get '/bar' do
- "bar"
-end
+ get '/bar' do
+ "bar"
+ end
```
Note that in the example above, you would ease testing and increase performance
@@ -1041,13 +1214,13 @@ set the body at an arbitrary point in the execution flow. You can do so with the
access the body:
```ruby
-get '/foo' do
- body "bar"
-end
+ get '/foo' do
+ body "bar"
+ end
-after do
- puts body
-end
+ after do
+ puts body
+ end
```
It is also possible to pass a block to `body`, which will be executed by the
@@ -1056,13 +1229,13 @@ Rack handler (this can be used to implement streaming, see "Return Values").
Similar to the body, you can also set the status code and headers:
```ruby
-get '/foo' do
- status 418
- headers \
- "Allow" => "BREW, POST, GET, PROPFIND, WHEN",
- "Refresh" => "Refresh: 20; http://www.ietf.org/rfc/rfc2324.txt"
- body "I'm a tea pot!"
-end
+ get '/foo' do
+ status 418
+ headers \
+ "Allow" => "BREW, POST, GET, PROPFIND, WHEN",
+ "Refresh" => "Refresh: 20; http://www.ietf.org/rfc/rfc2324.txt"
+ body "I'm a tea pot!"
+ end
```
Like `body`, `headers` and `status` with no arguments can be used to access
@@ -1076,15 +1249,15 @@ the client closes the connection. You can use the `stream` helper to avoid
creating your own wrapper:
```ruby
-get '/' do
- stream do |out|
- out << "It's gonna be legen -\n"
- sleep 0.5
- out << " (wait for it) \n"
- sleep 1
- out << "- dary!\n"
- end
-end
+ get '/' do
+ stream do |out|
+ out << "It's gonna be legen -\n"
+ sleep 0.5
+ out << " (wait for it) \n"
+ sleep 1
+ out << "- dary!\n"
+ end
+ end
```
This allows you to implement streaming APIs,
@@ -1105,34 +1278,34 @@ execution flow. This only works on evented servers, like Thin and Rainbows.
Other servers will still close the stream:
```ruby
-# long polling
+ # long polling
-set :server, :thin
-connections = []
+ set :server, :thin
+ connections = []
-get '/subscribe' do
- # register a client's interest in server events
- stream(:keep_open) { |out| connections << out }
+ get '/subscribe' do
+ # register a client's interest in server events
+ stream(:keep_open) { |out| connections << out }
- # purge dead connections
- connections.reject!(&:closed?)
+ # purge dead connections
+ connections.reject!(&:closed?)
- # acknowledge
- "subscribed"
-end
+ # acknowledge
+ "subscribed"
+ end
-post '/message' do
- connections.each do |out|
- # notify client that a new message has arrived
- out << message << "\n"
+ post '/message' do
+ connections.each do |out|
+ # notify client that a new message has arrived
+ out << message << "\n"
- # indicate client to connect again
- out.close
- end
+ # indicate client to connect again
+ out.close
+ end
- # acknowledge
- "message received"
-end
+ # acknowledge
+ "message received"
+ end
```
### Logging
@@ -1140,10 +1313,10 @@ end
In the request scope, the `logger` helper exposes a `Logger` instance:
```ruby
-get '/' do
- logger.info "loading data"
- # ...
-end
+ get '/' do
+ logger.info "loading data"
+ # ...
+ end
```
This logger will automatically take your Rack handler's logging settings into
@@ -1155,11 +1328,11 @@ default, so if you inherit from `Sinatra::Base`, you probably want to
enable it yourself:
```ruby
-class MyApp < Sinatra::Base
- configure :production, :development do
- enable :logging
- end
-end
+ class MyApp < Sinatra::Base
+ configure :production, :development do
+ enable :logging
+ end
+ end
```
To avoid any logging middleware to be set up, set the `logging` setting to
@@ -1173,18 +1346,18 @@ When using `send_file` or static files you may have mime types Sinatra
doesn't understand. Use `mime_type` to register them by file extension:
```ruby
-configure do
- mime_type :foo, 'text/foo'
-end
+ configure do
+ mime_type :foo, 'text/foo'
+ end
```
You can also use it with the `content_type` helper:
```ruby
-get '/' do
- content_type :foo
- "foo foo foo"
-end
+ get '/' do
+ content_type :foo
+ "foo foo foo"
+ end
```
### Generating URLs
@@ -1193,7 +1366,7 @@ For generating URLs you should use the `url` helper method, for instance, in
Haml:
```ruby
-%a{:href => url('/foo')} foo
+ %a{:href => url('/foo')} foo
```
It takes reverse proxies and Rack routers into account, if present.
@@ -1205,51 +1378,51 @@ This method is also aliased to `to` (see below for an example).
You can trigger a browser redirect with the `redirect` helper method:
```ruby
-get '/foo' do
- redirect to('/bar')
-end
+ get '/foo' do
+ redirect to('/bar')
+ end
```
Any additional parameters are handled like arguments passed to `halt`:
```ruby
-redirect to('/bar'), 303
-redirect 'http://google.com', 'wrong place, buddy'
+ redirect to('/bar'), 303
+ redirect 'http://google.com', 'wrong place, buddy'
```
You can also easily redirect back to the page the user came from with
`redirect back`:
```ruby
-get '/foo' do
- "do something"
-end
+ get '/foo' do
+ "do something"
+ end
-get '/bar' do
- do_something
- redirect back
-end
+ get '/bar' do
+ do_something
+ redirect back
+ end
```
To pass arguments with a redirect, either add them to the query:
```ruby
-redirect to('/bar?sum=42')
+ redirect to('/bar?sum=42')
```
Or use a session:
```ruby
-enable :sessions
+ enable :sessions
-get '/foo' do
- session[:secret] = 'foo'
- redirect to('/bar')
-end
+ get '/foo' do
+ session[:secret] = 'foo'
+ redirect to('/bar')
+ end
-get '/bar' do
- session[:secret]
-end
+ get '/bar' do
+ session[:secret]
+ end
```
### Cache Control
@@ -1259,27 +1432,27 @@ Setting your headers correctly is the foundation for proper HTTP caching.
You can easily set the Cache-Control header like this:
```ruby
-get '/' do
- cache_control :public
- "cache it!"
-end
+ get '/' do
+ cache_control :public
+ "cache it!"
+ end
```
Pro tip: Set up caching in a before filter:
```ruby
-before do
- cache_control :public, :must_revalidate, :max_age => 60
-end
+ before do
+ cache_control :public, :must_revalidate, :max_age => 60
+ end
```
If you are using the `expires` helper to set the corresponding header,
`Cache-Control` will be set automatically for you:
```ruby
-before do
- expires 500, :public, :must_revalidate
-end
+ before do
+ expires 500, :public, :must_revalidate
+ end
```
To properly use caches, you should consider using `etag` or `last_modified`.
@@ -1288,19 +1461,19 @@ will immediately flush a response if the client already has the current
version in its cache:
```ruby
-get '/article/:id' do
- @article = Article.find params[:id]
- last_modified @article.updated_at
- etag @article.sha1
- erb :article
-end
+ get '/article/:id' do
+ @article = Article.find params[:id]
+ last_modified @article.updated_at
+ etag @article.sha1
+ erb :article
+ end
```
It is also possible to use a
[weak ETag](http://en.wikipedia.org/wiki/HTTP_ETag#Strong_and_weak_validation):
```ruby
-etag @article.sha1, :weak
+ etag @article.sha1, :weak
```
These helpers will not do any caching for you, but rather feed the necessary
@@ -1308,16 +1481,16 @@ information to your cache. If you are looking for a quick reverse-proxy caching
solution, try [rack-cache](https://github.com/rtomayko/rack-cache):
```ruby
-require "rack/cache"
-require "sinatra"
+ require "rack/cache"
+ require "sinatra"
-use Rack::Cache
+ use Rack::Cache
-get '/' do
- cache_control :public, :max_age => 36000
- sleep 5
- "hello"
-end
+ get '/' do
+ cache_control :public, :max_age => 36000
+ sleep 5
+ "hello"
+ end
```
Use the `:static_cache_control` setting (see below) to add
@@ -1331,17 +1504,17 @@ resources (for instance for post requests), are treated as new resources. You
can change this behavior by passing in a `:new_resource` option:
```ruby
-get '/create' do
- etag '', :new_resource => true
- Article.create
- erb :new_article
-end
+ get '/create' do
+ etag '', :new_resource => true
+ Article.create
+ erb :new_article
+ end
```
If you still want to use a weak ETag, pass in a `:kind` option:
```ruby
-etag '', :new_resource => true, :kind => :weak
+ etag '', :new_resource => true, :kind => :weak
```
### Sending Files
@@ -1349,15 +1522,15 @@ etag '', :new_resource => true, :kind => :weak
For sending files, you can use the `send_file` helper method:
```ruby
-get '/' do
- send_file 'foo.png'
-end
+ get '/' do
+ send_file 'foo.png'
+ end
```
It also takes options:
```ruby
-send_file 'foo.png', :type => :jpg
+ send_file 'foo.png', :type => :jpg
```
The options are:
@@ -1374,8 +1547,8 @@ The options are:
disposition
- used for Content-Disposition, possible values: `nil` (default),
- `:attachment` and `:inline`
+ used for Content-Disposition, possible value: nil
(default),
+ :attachment
and :inline
length
@@ -1641,19 +1814,20 @@ You can also hand in an array in order to disable a list of protections:
Enable if your app is running behind a reverse proxy that has not been set up
- properly. Note that the `url` helper will still produce absolute URLs, unless you
- pass in `false` as the second parameter.
+ properly. Note that the url
helper will still produce absolute URLs, unless you
+ pass in false
as the second parameter.
Disabled per default.
add_charsets
- mime types the `content_type` helper will automatically add the charset info to.
+ mime types the content_type
helper will automatically add the charset info to.
You should add to it rather than overriding this option:
-```ruby
- settings.add_charsets << "application/foobar"
-```
+
+
+ settings.add_charsets << "application/foobar"
+
app_file
@@ -1665,14 +1839,14 @@ You can also hand in an array in order to disable a list of protections:
IP address to bind to (default: 0.0.0.0). Only used for built-in server.
default_encoding
-encoding to assume if unknown (defaults to `"utf-8"`).
+encoding to assume if unknown (defaults to "utf-8"
).
dump_errors
display errors in the log.
environment
- current environment, defaults to `ENV['RACK_ENV']`, or `"development"` if
+ current environment, defaults to ENV['RACK_ENV']
, or "development"
if
not available.
@@ -1688,7 +1862,7 @@ You can also hand in an array in order to disable a list of protections:
method_override
- use `_method` magic to allow put/delete forms in browsers that
+ use _method
magic to allow put/delete forms in browsers that
don't support it.
@@ -1697,22 +1871,22 @@ You can also hand in an array in order to disable a list of protections:
prefixed_redirects
- Whether or not to insert `request.script_name` into redirects if no
- absolute path is given. That way `redirect '/foo'` would behave like
- `redirect to('/foo')`. Disabled per default.
+ Whether or not to insert request.script_name
into redirects if no
+ absolute path is given. That way redirect '/foo'
would behave like
+ redirect to('/foo')
. Disabled per default.
protection
Whether or not to enable web attack protections. See protection section above.
public_dir
- Alias for `public_folder`. See below.
+ Alias for public_folder
. See below.
public_folder
Path to the folder public files are served from. Only used if static
- file serving is enabled (see `static` setting below). Inferred from
- `app_file` setting if not set.
+ file serving is enabled (see static
setting below). Inferred from
+ app_file
setting if not set.
reload_templates
@@ -1722,13 +1896,13 @@ You can also hand in an array in order to disable a list of protections:
root
- Path to project root folder. Inferred from `app_file` setting if not set.
+ Path to project root folder. Inferred from app_file
setting if not set.
raise_errors
raise exceptions (will stop application). Enabled by default when
- `environment` is set to `"test"`, disabled otherwise.
+ environment
is set to "test"
, disabled otherwise.
run
@@ -1748,18 +1922,18 @@ You can also hand in an array in order to disable a list of protections:
sessions
- Enable cookie-based sessions support using `Rack::Session::Cookie`.
+ Enable cookie-based sessions support using Rack::Session::Cookie
.
See 'Using Sessions' section for more information.
show_exceptions
Show a stack trace in the browser when an exception
- happens. Enabled by default when `environment`
- is set to `"development"`, disabled otherwise.
+ happens. Enabled by default when environment
+ is set to "development"
, disabled otherwise.
- Can also be set to `:after_handler` to trigger
+ Can also be set to :after_handler
to trigger
app-specified error handling before showing a stack
trace in the browser.
@@ -1776,23 +1950,23 @@ You can also hand in an array in order to disable a list of protections:
static_cache_control
When Sinatra is serving static files, set this to add
- `Cache-Control` headers to the responses. Uses the
- `cache_control` helper. Disabled by default.
+ Cache-Control
headers to the responses. Uses the
+ cache_control
helper. Disabled by default.
Use an explicit array when setting multiple values:
- `set :static_cache_control, [:public, :max_age => 300]`
+ set :static_cache_control, [:public, :max_age => 300]
threaded
- If set to `true`, will tell Thin to use `EventMachine.defer`
+ If set to true
, will tell Thin to use EventMachine.defer
for processing the request.
- views**
+ views
- Path to the views folder. Inferred from `app_file` setting if
+ Path to the views folder. Inferred from app_filei
setting if
not set.