Sinatra

Sinatra v2.1.0

2020-09-05T00:00:00+00:00

Today we would like to inform you that we have released Sinatra v2.1.0. It’s a big milestore for us and contains some bug fixes and new features.

Releases

This release includes the release of the following gems:

sinatra: v2.1.0
sinatra-contrib: v2.1.0
rack-protection: v2.1.0

Key Updates

Ruby 2.2. support was dropped

Ruby 2.2 support is dropped from this version. We will no longer check the operation on Ruby 2.2. Please upgrade your ruby version if you’re still using Ruby 2.2.

Migrating from Thin to Rainbows in our development environment

From this version, we migrated from thin to rainbows in our development environment. This does not mean that the stream block will be immediately broken. The change was triggered by the removal of the thin handler in rack, but in fact thin hasn’t been maintained for a long time.

Rainbows on the stream feature

Our stream feature has been tested by thin for many years. From this version, it is replaced with rainbows. This does not mean that the stream block will be immediately broken by thin.

However, we recommend migrating to rainbows if you want to use the stream feature. Please have a look at our README to know how to integrate with Rainbows.

Changes

Find out what’s new in v2.1.0 in CHANGELOG

Thank you

Thank you everyone who has contributed over the years to this project, and continues to ensure it lives on. In addition, want to give a special thanks to the key contributor for this release: @rkmathi

Join us

We are looking for fellows who can actively help with our development. I would be pleased if you could actively triage bugs on github, help with issues, and cooperate for v3.0.0.

Happy new year & Sinatra 2.0.8!

2020-01-01T00:00:00+00:00

We would like to inform you that we have released Sinatra v2.0.8.

Releases

This release includes the release of the following gems:

sinatra: v2.0.8
sinatra-contrib: v2.0.8
rack-protection: v2.0.8

Changes

Find out what’s new in v2.0.8 in CHANGELOG

Thank you

Thank you everyone who has contributed over the years to this project, and continues to ensure it lives on.

A new maintainer and Sinatra 2.0.6!

2019-08-21T00:00:00+00:00

We would like to inform you that we have released Sinatra v2.0.6. Not only that, but we also have a great news for us!

Before we begin to touch release note, I want to introduce the great news.

Welcome to the team, Jordan!

Please join me in welcoming Jordan Owens to the core team on Sinatra! He has already done a lot of contributions on our projects, including sinatra, sinatra-contrib and rack-protection. As you can see, the achievements he has made are very enormous. I’m convinced that by welcoming him to the team, Sinatra will become more wonderful.

Sinatra has a schedule for major renovations for v3.0.0, and I expect Jordan to show strong leadership and his great technical skill in that milestone.

Once more, welcome to the team, Jordan!

Releases

This release includes the release of the following gems:

sinatra: v2.0.6
sinatra-contrib: v2.0.6
rack-protection: v2.0.6

Changes

Find out what’s new in v2.0.6 in CHANGELOG

Thank you

Thank you everyone who has contributed over the years to this project, and continues to ensure it lives on. In addition, want to give a special thanks to the key contributor for this release: @304

Join us

We are looking for fellows like Jordan who can actively help with our development. I would be pleased if you could actively triage bugs on github, help with issues, and cooperate for v3.0.0.

Sinatra 2.0.5

2018-12-23T00:00:00+00:00

We would like to inform you that we have released Sinatra v2.0.5.

Before we begin, I want to thank everyone who contributed, and continued to use and support the project.

Releases

This release includes the release of the following gems:

sinatra: v2.0.5
sinatra-contrib: v2.0.5
rack-protection: v2.0.5

Erubi Support

We officially began supporting Erubi. Please report something when combining Sinatra and Erubi if there is something wrong.

Thanks for the suggestion, @tkmru!

Changes

Find out what’s new in v2.0.5 in CHANGELOG

Thank you

Thank you everyone who has contributed over the years to this project, and continues to ensure it lives on. In addition, want to give a special thanks to the key contributors for this release: @jkowens, @tkmru

Join us

We are currently working on discussing the release cycle and activating the community to make Sinatra development better. Sinatra has a lot of issues. Please join us if you’re interested in our development.

Sinatra: Contributing

Sinatra 2.0.2 and 2.0.3 are out

2018-06-09T00:00:00+00:00

We would like to inform you that we have released Sinatra v2.0.2 and v2.0.3.

Before we begin, I want to thank everyone who contributed, helped test pre-releases, and continues to use and support the project.

Security Fix CVE-2018-11627

Sinatra had a critical vulnerability since v2.0.0. The purpose of this release is to fix CVE-2018-11627.

The vulnerability is that XSS can be executed by using illegal parameters. The issue was reported by @JokerCatz. Thank you so much.

If you’re using Sinatra v2.0.x, please upgrade to v2.0.2 or later.’

Releases

This release includes the release of the following gems, and associated versions:

sinatra: v2.0.2, v2.0.3
sintra-contrib: v2.0.2, v2.0.3
rack-protection: v2.0.2, v2.0.3

What is the difference between v2.0.3 and v2.0.2 ?

In sinatra-contrib v2.0.2, a critical regression was found for the backports gem. Version 2.0.3 fixes the issue by merging a patch sent by author of the backports gem.

We thank everyone who reported and confirmed the issue.

Changes

Find out what’s new in v2.0.2 and v2.0.3 in CHANGELOG.md

Thank you

Thank you everyone who has contributed over the years to this project, and continues to ensure it lives on. Finally, I am deeply grateful to Shota Iguchi who worked on the v2.0.2 improvement.

Rack::Protection v1.5.5 is out

2018-03-08T00:00:00+00:00

I have just released Rack Protection v1.5.5 for backporting security fix.

Details

The v1.5.5 contains a security fix for CVE-2018-1000119.

It was determined a timing attack vulnerability in the CSRF token checking that can result in signatures being exposed.

The original fix has already been merged at rack-protection v2.0.0.rc3. Therefore, there is no problem if you are using rack-protection v2.0.0.rc3 or later.

At first of all, we strongly recommend that you check the version of rack-protection you are currently using on your application. You can confirm that by looking at the version of rack-protection embedded in Gemfile.lock.

As a result, if you still are using rack-protection v1.5.4 or earlier, we would highly recommend to upgrade the gem.

Thank you

Finally, I am deeply grateful to Andreas Karlsson and Kurt Seifried who worked on this issue. Thank you.

Sinatra 2.0.1 is out!

2018-02-19T00:00:00+00:00

I have just released Sinatra v2.0.1 and Mustermann v1.0.2.

Before we begin, I want to thank everyone who contributed, helped test pre-releases, and continues to use and support the project.

Security Fix CVE-2018-7212

The rack-protection-v2.0.1 contains a security fix for CVE-2018-7212.

It was determined a path traversal attack using backslashes was possible on Windows environment. We highly recommend you upgrade at least rack-protection if you’re on Windows, or apply this patch provided by Orange Tsai from DEVCORE.

If you’re on older version of Sinatra, we have backported this patch to rack-protection in v1.5.4.

Releases

Sinatra v2.0.1 includes the release of the following gems, and associated versions:

sinatra: v2.0.1
sinatra-contrib: v2.0.1
rack-protection: v2.0.1
mustermann: v1.0.2
mustermann-contrib: v1.0.2

sinatra, sinatra-contrib and rack-protection v2.0.1

Find out what’s new in 2.0.1 in CHANGELOG.md

mustermann and mustermann-contrib v1.0.2

Find out what’s new in 1.0.2 in CHANGELOG.md

Thank you

Thank you everyone who has contributed over the years to this project, and continues to ensure it lives on.

Sinatra Two Point Oh!

2017-05-15T00:00:00+00:00

Today, I’m pleased to FINALLY announce that Sinatra 2.0 was released!

If you haven’t been following along, the major version bump includes a lot of changes significant to the future of the project.

In this post, you will see the full details including what’s new, what’s gone, and everything packed into the two point oh release.

Before we begin, I have to thank everyone who contributed, helped test pre-releases, and continues to use and support the project.

Releases

Sinatra 2.0 includes the release of the following gems, and associated verions:

sinatra: v2.0.0
sinatra-contrib: v2.0.0
mustermann: v1.0.0
mustermann-contrib: v1.0.0
rack-protection: v2.0.0

You can download all of these gems from rubygems.org.

Major features

Rack 2.0 support, Rack 1.x is no longer supported
Ruby 2.2+ support, Ruby < 2.2 is no longer supported
Sinatra router replaced with Mustermann
Compatible with Rails 5! :trollface:

Sinatra core

Many of you have been waiting since before the Rails 5 release, for a Sinatra 2.0 pre-release.

Before we get into the changes, I want to address something.

Why 2.0 was delayed

First, there was a ridiculous number of tickets asking for a release, so many that I actually lost count to be honest.

Let me just say, thank you everyone for your patience and I hope that this release is worth the wait!

To put it short.

When I took on the challenge of releasing Sinatra 2.0, my goal was to not only bump minimum dependency requirements – but also make sure Sinatra is well maintained and provide the level of class people have come to expect from the project and it’s previous maintainer.

With that said, I hope the following features and changes that went into the release can live up to (not only mine) but everyone’s expectations.

Features

Use Mustermann for patterns PR by Konstantin Haase
Server now provides -q flag for quiet mode, which disables start/stop messages PR by Vasiliy
Session middleware can now be specified with :session_store setting PR by Jordan Owens
APP_ENV is now preferred and recommended over RACK_ENV for setting environment PR by Damien Mathieu
Reel support PR by Patricio Mac Adden

Changes

The following notable changes are also included in this release.

Make route params available during error handling PR by Jeremy Evans
Unify not_found and error 404 behavior PR by Jeremy Evans
Enable Ruby 2.3 frozen_string_literal feature PR by Vladimir Kochnev
Add Sinatra::ShowExceptions::TEMPLATE and patched Rack::ShowExceptions to prefer Sinatra template commit by Zachary Scott
Sinatra::Runner is used internally for integration tests PR by Nick Sutterer
Fix case-sensitivity issue in uri method PR by rennex
Use Rack::Utils.status_code to allow status helper to use symbol as well as numeric codes PR by Tobias H. Michaelsen
Improved error handling for invalid params through Rack PR by Jordan Owens
Ensure template is cached only once PR by Patrik Rak
Use same session_secret for classic and modular apps in development PR by Marcus Stollsteimer
Improve Session Secret documentation to encourage better security practices PR by Glenn Rempe
Exposed global and per-route options for Mustermann route parsing PR by Mike Pastore
Capture exception messages of raised NotFound and BadRequest PR by Mike Pastore
Add :strict_paths option for managing trailing slashes PR by namusyaka
Add full IndifferentHash implementation to params PR by Mike Pastore and PR by John Hope

Now let’s take a look at the peripheral work that went into the release of Sinatra 2.0.

Sinatra::Contrib

This gem provides a bunch of helpful extensions for common patterns that can be applied to your Sinatra application. Take a look at the documentation for a list of what you get.

The biggest change to the sinatra-contrib gem is that it is now bundled in the Sinatra source tree. Ticket by Zachary Scott.

Since the release, if you install the gem though you shouldn’t notice any difference. Alternitively you can install the gem from source, like so:

# Gemfile
github 'sinatra/sinatra' do
  gem 'sinatra-contrib'
end

This will fetch the sinatra git source and install the gem from the tree.

Also, we’ve consolidated the bug trackers, and you can now find sinatra-contrib related issues under this label.

Features

Here are the new features in Sinatra::Contrib.

Sinatra::Contrib is now bundled in the Sinatra source tree PR
Sinatra::ContentFor added clear_content_for method PR by Ben Darlow
Sinatra::Namespace support for Mustermann PR by Vasiliy and Jordan Owens (PR)
Sinatra::RequiredParams for permitting required query parameters PR by Daisuke Taniwaki
Sinatra::Runner PR by Nick Sutterer
Sinatra::WebDAV PR by Yegor Timoshenko Originally submitted by Mark Bates
Sinatra::Reloader added after_reload hook which allows manual reload changes when triggered PR by Jhimy Fernandes Villar

Changes

And the following notable changes that went into the release.

Migrate specs to RSpec 3.4 PR by Jhimy Fernandes Villar
Sinatra::ConfigFile allow ERB syntax in YML files PR by Jhimy Fernandes Villar
Sinatra::ContentFor renders given block if specified key is not found PR by Micah Redding
Sinatra::ContentFor can yield an immediate value, similar to ActionView PR by Ryo Nakamura
Sinatra::LinkHeader to use “,\n” (comma, new-line) as delimiter PR by petedmarsh
Sinatra::Namespace allow using redirect_to in a namespace PR by Jhimy Fernandes Villar
Sinatra::RespondWith swallow exception from Tilt on LoadError for missing template PR by Matt Austin
Sinatra::RespondWith now raises a 500 error if formatting fails commit
Make Rack::Test a development dependency PR by Mike Pastore
Add explicit set method to contrib/cookies to override cookie settings PR by Andrew Allen
Avoid executing filters even if prefix matches with other namespace PR by namusyaka

Removals

Sinatra::Decompile is no longer necessary after added Mustermann support commit by Zachary Scott

For full details, compare the pre-merged diff and milestone.

Rack::Protection

This gem is designed to provide several middleware for protecting your applications against common web attacks. Take a look at the documentation for more information.

The biggest change to the rack-protection gem is that it is now bundled in the Sinatra source tree. PR by Zachary Scott.

Although I must admit, this change wasn’t without pitfalls, I apologize to everyone affected during the transition time.

Since the release, if you install the gem though you shouldn’t notice. Alternitively you can install the gem from source, like so:

# Gemfile
github 'sinatra/sinatra' do
  gem 'rack-protection'
end

This will fetch the sinatra git source and install the gem from the tree.

Also, we’ve consolidated the bug trackers, and you can now find rack-protection related issues under this label.

Features

Here are the new features in Rack::Protection

Rack::Protection::ContentSecurityPolicy PR by Christian Meier with Level 2 and 3 Directives in PR by Glenn Rempe
Rack::Protection::HttpOrigin and AuthenticityToken added :allow_if option to specify allowable urls PR by Nathan Stitt
Rack::Protection::CookieTossing PR by Jordan Owens
Rack::Protection::AuthenticityToken prevent BREACH attack PR by Jordan Owens
Added :without_session option to initializer to easily skip session-based protections commit by Zachary Scott

Changes

Along with the following notable changes that went into the release.

Migrate spaces to RSpec 3 PR by Maurizio De Santis
Rack::Protection::StrictTransport PR by Maciej Moleda
Rack::Protection::JsonCsrf closes body on prevented attack PR by Konstantin Haase
Use Rack::Utils.secure_compare when checking CSRF tokens commit by Andreas Karlsson
Rack::Protection::EscapedParams ensures Tempfile is untouched PR by Albert Engelbrecht
Adds preload option to Rack:Protection:StrictTransport PR by Ed Robinson
Add allow_if option to bypass json csrf protection PR by Jordan Owens

For full details, compare the pre-merged diff.

Mustermann

Mustermann is a powerful library with many features and compatible params parsing interface. It will replace the existing router in Sinatra for version 2.0.

Take a look at the documentation for more information.

Apart from the features and changes to the core of Mustermann, which I will list below, the biggest change in the first stable release is organizational.

mustermann-everything gem is deprecated
mustermann-contrib has replaced it, including all non-core extensions

Please check the PR for the full list of included plugins, but I hope this change will make maintaining and releasing Mustermann much simpler from now on.

Features

Here are the latest features in Mustermann version 1.0.

Rails patterns: Add Rails 5.0 compatibility mode, make it default. commit by Konstantin Haase
Add concatenation support (Mustermann::Pattern#+). commit by Konstantin Haase
Mustermann::Grape PR by namusyaka
Implement shorthand for ({foo} {bar}) pattern PR by namusyaka
Sinatra patterns: Allow | outside of parens commit by Konstantin Haase
Mustermann::Sinatra#| may now generate a Sinatra pattern instead of a real composite commit by Konstantin Haase

Changes

Along with the following notable changes that went into the release.

Moved non-core extensions to meta mustermann-contrib gem PR by Zachary Scott
Move Tool::EqualityMap from tool gem to Mustermann::EqualityMap PR by Michael Stock
Remove routers (they were out of scope for the main gem). commit by Konstantin Haase

For the full details, compare the diff.

Wrapping up

In the end, there’s still more work to be done on the project and a bright future ahead.

At the time of writing this, there are almost 30 open issues and about 10 pull requests.

There are a number of places where Sinatra could improve, and although I’ve added a number of tickets for features, I’d like to end this by briefly listing some of these areas specifically.

Logging

Currently, Sinatra uses Rack::Logger middleware under the hood with a little bit extra.

This logger is barebones, and I’m sure we could build a much nicer logging API by ourselves that would prove more useful for dealing with production services.

Streaming

There have been a number of discussions on streaming, but I feel this is something that could definitely be improved.

While, there are some missing features mentioned, when this API was originally implemented Rack’s hijack api was still unfinished.

I don’t exactly know the best route for this, but probably start with something in the Rack layer – like is already being discussed. Then we can provide an API on top of that inside Sinatra’s DSL. For added bonus, we could wrap something like Sinatra::Streaming to make it really nice.

Exception Handling

The current implementation for error handling comes down to “handle_exception!”.

This method to me looks like it’s begging for a refactor, and just the cause of a bad API design (sorry).

What I mean is, it could definitely be improved, and maybe it’s “bad design” but hey it works! Right!

Also take a look at “error_block!” and “dump_errors!”.. what!

All of this along with a middleware, called “ShowExceptions”, for displaying errors both/either in plain-text and/or html.

Wait there’s more!

Without going into too much detail, route dispatch (including before/after filters) needs work. As well, @rkh has mentioned wanting to improve the Template API.

There is also stuff like an implementation of “indifferent_params” and “indifferent_hash”, that could be upstreamed in Ruby.

At any rate, there’s more than a few things here as well as a number of great ideas from @rkh himself that should keep us busy for a while.

Briefly about deprecations

One thing I want to say before I end this post, please please please pleeeease:

Do not send PRs to remove deprecations or unfactored code without good reason.

I won’t consider any changes like this until we start thinking about version 2.1.

Thank you

At any rate, I hope that Sinatra 2.0 is everything you hoped for and more, and apologize if your patch or bug wasn’t included in the release.

Thank you everyone who has contributed over the years to this project, and continues to ensure it lives on.

In the words of the great Nat King Cole, you’re unforgettable.

Sinatra 1.4.0, 1.3.6, 1.2.9 released!

2013-03-15T00:00:00+00:00

I’ve just released Sinatra 1.4.0, 1.3.6 and 1.2.9.

Find out what’s new in 1.4 on my blog.

New feature release, Contrib and Recipes

2011-09-30T00:00:00+00:00

We’re proud to announce two new releases today: 1.3.0 and 1.2.7. We’re also simultaneously releasing sinatra-contrib and would like to officially announce the recently launched Sinatra Recipes project. Read on for more goodness!

Sinatra 1.3.0

We have a new feature release!

From our perspective, one of the biggest additions is a streaming API. A simple version of it ships with Sinatra directly and is extended in sinatra-contrib. The vanilla version looks like this:

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

The cool thing about this is that it abstracts away the differences between all the different Rack servers, no matter if those are evented (like Thin, Rainbows! or Ebb) or sequential (like Unicorn, Passenger or Mongrel). Only WEBRick has issues with it at the moment (you’ll get the response body all at once), but we are looking into this.

What is really interesting about this: If you run on an evented server, like Thin, you can keep the connection open and easily implement messaging services, Server-Sent Events and so on:

set :server, :thin
connections = []

get '/' do
  # keep stream open
  stream(:keep_open) { |out| connections << out }
end

post '/' do
  # write to all open streams
  connections.each { |out| out << params[:message] << "\n" }
  "message sent"
end

It is worth mentioning that all this works without fibers (which, amongst other things, would significantly limit the stack size).

We added support for the PATCH HTTP verb, which you might be familiar with from the new GitHub API:

patch '/' do
  # ... modify a resource ...
end

A logger helper for logging is available now, and if it writes to the logs depends on whether you enabled or disabled logging:

configure(:test) { disable :logging }

get '/' do
  logger.info "I just want to let you know: I'll take care of the request!"
  "Hello World!"
end

The erubis method has been deprecated. Sinatra will automatically use Erubis for rendering ERB templates if available.

There is more coming with this release, but the rest is mainly bug fixes and improving the behavior. For instance, Sinatra treats ETags and Last-Modified headers properly when they are used as optimistic locking for unsafe HTTP verbs. For more changes, see the 1.3.0 change log.

Special thanks for helping with the 1.3.0 release go to:

Gabriel Andretta, michelc, burningTyger, Tim Felgentreff, Vasily Polovnyov, nashby, kenichi nakamura, Gaku Ueda, Gabriel Horner, Sylvain Desvé, Jacob Burkhart & Josh Lane, aibo (irc), Selman ULUG, Aviv Ben-Yosef, Paolo “Nusco” Perrotta, Marcos Toledo, Matthew Schinckel, Tim Preston, Davide D’Agostino, Simone Carletti, Peter Suschlik, Postmodern, F. Zhang, Rémy Coutable, and David Waite

Sinatra 1.2.7

We will drop support for Rack prior to 1.3 and Ruby 1.8.6 with the Sinatra 1.3.0 release. However, we will continue to supply Sinatra 1.2 with bug fixes until the End-Of-Life of Rack 1.2.x and Sinatra 1.2 will always remain compatible with the latest released 1.8.6 patchlevel.

For the backported patches, see the 1.2.7 change log.

We’d like to thank everyone helping with the 1.2.7 release:

Emanuele Vicentini, Takanori Ishikawa, David Kellum, Gaku Ueda, Lee Reilly, Iain Barnett, pete, Luke Jahnke, John Wolfe, Andrew Armenia, Tim Felgentreff, and Alessandro Dal Grande

Sinatra-Contrib

There are a lot of Sinatra extensions out there, and some of those are used by a large number of apps, like sinatra-content-for or sinatra-reloader. The maintainers of these extensions have to keep up with new Sinatra releases to make sure everything works fine. This poses an issue from time to time, especially since some of these extensions were relying on Sinatra internals. To fix this, we created the sinatra-contrib project (source code at https://github.com/sinatra/sinatra-contrib). This project contains a number of extensions that are probably useful for most Sinatra applications. Some are old extensions that have largely been rewritten to ensure the code quality developers are used to from Sinatra itself and to no longer rely on internals, like sinatra-namespace, and some are new additions of general interest, for example sinatra-respond-with.

Here is the promise: For every Sinatra release, starting with 1.3.0, there will always be a fully compatible sinatra-contrib release. Documentation for all the extensions shipping with sinatra-contrib will be made available on the Sinatra website. I would not have managed to take care of this all by my self, so I’m really grateful that Gabriel Andretta jumped in to help with this project.

Documentation is available at sinatrarb.com/contrib.

Sinatra Recipes

Zachary Scott recently launched the Recipes project. It contains community contributed recipes and techniques for Sinatra.

Sinatra Loves Dancer

2011-07-21T00:00:00+00:00

“The only cool PR is provided by one’s enemies. They toil incessantly and for free.” - Marshall McLuhan

There are a lot of frameworks out there inspired by Sinatra. One of them is Dancer. Some unknown individual or group was posing as different members of the Sinatra core team on CPAN ratings, a website to comment on the quality of Perl libraries.

Those comments were extremely rude and do not represent the opinion of any of the Sinatra developers. Quite the opposite, we love how Sinatra inspired so many of the libraries and are even proud to see Dancer being adopted by Perl developers.

We do not know what the agenda of this one individual is, and honestly, we do not care. The harm done by this person to the Dancer project, the Sinatra project and the people he posed as is unacceptable. The incident has been reported to the CPAN ratings team and we hope that those comments will be removed in due time.

If you are a Perl developer, we suggest you check out Dancer.

What's New in Sinatra 1.2?

2011-03-03T00:00:00+00:00

As announced on the mailing list, we have just released Sinatra 1.2.0. Let’s have a closer look at the new features.

Slim support

Sinatra now supports the Slim Template Engine:

require 'sinatra'
require 'slim'

get('/') { slim :index }

__END__

@@ index
! doctype html
html
  head
    title Sinatra With Slim
  body
    h1 Slim Is Fun!
    a href="https://haml-lang.com/" A bit like Haml, don't you think?

Inline Markaby

Like Builder and Nokogiri templates, Markaby can now be used directly inline:

require 'sinatra'
require 'markaby'

get '/' do
  markaby do
    html do
      head { title "Sinatra With Markaby" }
      body { h1 "Markaby Is Fun!" }
    end
  end
end

Layout Engines

Whenever you render a template, like some_page.haml, Sinatra will use a corresponding layout, like layout.haml for you. With the :layout option it has always been possible to use a different layout, but it still had to be written in the same template language, Haml in our example. In 1.1 we introduced markdown, textile and rdoc templates. It is not possible to use those for layouts. We therefore added the :layout_engine option, which easily allows you to combine one two different template engines:

require 'sinatra'
require 'rdiscount'

# for all markdown files, use post.haml as layout
set :markdown, :layout_engine => :haml, :layout => :post

get '/' do
  # use index.haml for readme
  markdown :README, :layout => :index
end

get '/:post' do
  markdown params[:post].to_sym
end

This feature should also be handy when migrating from one template language to another, as it allows you to combine Erb with Haml, for instance.

Conditional Filters

We introduced pattern matching filters in 1.1. Now they also support conditions:

before :agent => /Song Bird/ do
  # ...
end

Those can also be combined with patterns, of course:

after '/api/*', :provides => :json do
  # ...
end

URL helper

Usually Sinatra does not provide any view helper methods. Those are provided by extensions and would not suit Sinatra’s approach of a small but robust core. However, constructing URLs is a use case most people run into sooner or later. It is a bit complicated to construct URLs right. Consider this example:

get('/foo') { "<a href='/bar'>Will you make it?</a>" }
get('/bar') { "You made it!" }

Feel free to run it. Works, doesn’t it? So, what is wrong with it?

Imagine your app is “mounted” by another Rack application, for instance in a config.ru like this:

map('/there') { run Sinatra::Application }
map('/') { run MyRailsApp::Application }

Now the link to /bar would end up in a request send to MyRailsApp rather than to Sinatra. Injecting request.script_name would fix this, but be honest, how often do you do that?

Now, imagine these links are presented out of context, in an RSS feed or embedded on another host. In that case you might want to construct absolute URLs. This is even more cumbersome, as you most certainly either forget to handle reverse proxies, alternative ports/protocols or you end up with lots of URL related code all over the place, while what you should do is use the url helper:

get('/foo') { "<a href='#{url '/bar'}'>You will make it!</a>" }
get('/bar') { "You made it!" }

Since you are likely going to use this with redirects, we also aliased the helper to to:

get('/foo') { redirect to('/bar') }
get('/bar') { "You made it!" }

Named Captures on 1.9

Ruby 1.9 introduced named captures for regular expressions. Sinatra accepts regular expressions for matching paths. Now named captures will automatically end up populating params:

get %r{/(?<year>\d{4})/(?<month>\d{2})/(?<day>\d{2})/?} do
  date = Date.new params[:year].to_i, params[:month].to_i, params[:day].to_i
  @posts = Post.pubished_on date
  erb :posts
end

Templates with different scopes

All rendering methods now accept a :scope options:

get '/:id' do |id|
  @post = Post.find id

  # without scope
  erb "<%= @post.name %>"

  # with scope
  erb "<%= name %>", :scope => @post
end

Note that all Sinatra helper methods and instance variables will not be available.

Configurable redirects

In 1.1 we made sure all redirects were absolute URIs, to conform with RFC 2616 (HTTP 1.1). This will result in issues for you if you have a broken Reverse Proxy configuration. If so, you should really fix your configuration. If you are unable to do so, a simple disable :absolute_redirects will now give you back the 1.0 behavior. As shown above, you can now use the to helper with redirect. If all your redirects are application local, you can now enable :prefixed_redirects and skip the to altogether:

enable :prefixed_redirects
get('/foo') { redirect '/bar' }
get('/bar') { "You made it!" }

We did not enable this per default to not break compatibility and to allow you redirects to other Rack endpoints.

Overriding template lookup

One popular feature request is supporting multiple view folders. But everyone wants different semantics. So, instead of choosing one way to go, we gave you means to implement your own lookup logic:

helpers do
  def find_template(*)
    puts "looking for index.txt"
    yield "views/index.txt"
    puts "apparently, index.txt doesn't exist, let's try index.html"
    yield "views/index.html"
  end
end

get "/" do
  haml :foo
end

Sinatra will call find_template to discover the template file. In the above example, we don’t care about what template engine to use or what name the template has. It will use views/index.txt or views/index.html for every template. Let’s have a look at the standard implementation:

def find_template(views, name, engine)
  Tilt.mappings.each do |ext, klass|
    next unless klass == engine
    yield ::File.join(views, "#{name}.#{ext}")
  end
end

As you can see, it will look in the views folder for a file named like the template with any of the file extensions registered for the template engine.

If all you want to change is the folder, you probably should just call super:

def find_template(views, *a, &b)
  super("#{views}/a", *a, &b)
  super("#{views}/b", *a, &b)
end

More examples can be found in the readme.

Other changes

send_file now takes a :last_modified option
improved error handling

Blog revived

2011-03-03T00:00:00+00:00

It has been quiet on this blog recently. Announcements, like the 1.0 and 1.1 releases, have only been made on the mailing list. Plans are to change this and accompany mailing list announcements with in-depth articles about new feature releases.

We Have a FAQ Now

2009-01-29T00:00:00+00:00

Just getting started with Sinatra and wondering how to do something that should be obvious? Check out The FAQ. We culled a few weeks worth of IRC logs and mailing list threads to compile the initial set of entries and we’ll be adding to the list considerably over the coming weeks.

Have an idea for a FAQ entry? Fork the sinatra.github.com repository, add the entry to faq.markdown, and push. We’ll take care of the rest.

What's New in Sinatra 0.9.0

2009-01-18T00:00:00+00:00

This is the first in a series of 0.9.x releases designed to move Sinatra toward a rock solid 1.0. While we were able to add a touch of new hotness in this release, the major focus has been on getting the codebase shaped up for future development. Many longstanding bugs and minor annoyances were corrected along the way.

Sinatra’s internal classes and methods have changed significantly in this release. Most apps written for 0.3.x will work just fine under the new codebase but we’ve begun adding deprecation warnings for things slated to be ripped out completely in 1.0. Please test your apps before upgrading production environments to the 0.9.0 gem. We’re committed to keeping existing apps running through 0.9.x so report compatibility issues through the normal channels.

With that out of the way, here are some of the new features to look out for in 0.9.0.

Sinatra::Base and Proper Rack Citizenship

Sinatra can now be used to build modular / reusable Rack applications and middleware components. This means that multiple Sinatra applications can now be run in isolation and co-exist peacefully with other Rack based frameworks.

Requiring 'sinatra/base' instead of 'sinatra' causes a subset of Sinatra’s features to be loaded. No methods are added to the top-level and the command-line / auto-running features are disabled. Subclassing Sinatra::Base creates a Rack component with the familiar Sinatra DSL methods available in class scope. These classes can then be run as Rack applications or used as middleware components.

Proper documentation on this feature is in the works but here’s a quick example for illustration:

require 'sinatra/base'

class Foo < Sinatra::Base
  # all options are available for the setting:
  enable :static, :session
  set :root, File.dirname(__FILE__)

  # each subclass has its own private middleware stack:
  use Rack::Deflator

  # instance methods are helper methods and are available from
  # within filters, routes, and views:
  def em(text)
    "<em>#{text}</em>"
  end

  # routes are defined as usual:
  get '/hello/:person' do
    "Hello " + em(params[:person])
  end
end

That thing can be plugged in anywhere along a Rack pipeline. For instance, once Rails 2.3 ships, you’ll be able to use Sinatra apps to build Rails Metal.

Jesse Newland and Jon Crosby are already experimenting. Very hot.

Nested Params

Form parameters with subscripts are now parsed into a nested/recursive Hash structure. Here’s a form:

<form method='POST' action='/guestbook/'>
  <input type='text' name='person[name]'>
  <input type='text' name='person[email]'>
  <textarea name='note'></textarea>
</form>

It looks like this on the wire:

person[name]=Frank&person[email]=frank@theritz.com&message=Stay%20cool

Sinatra turns it into a nested Hash structure when accessed through the params method:

post '/guestbook/' do
  params[:person]    # => { :name => 'Frank', :email => 'frank@theritz.com' }
  "Hi #{person[:name]}! Thanks for signing my guestbook."
end

This was a massively popular feature requests. Thanks to Nicolás Sanguinetti for the patch and Michael Fellinger for the original implementation.

Routing with Regular Expressions

The route declaration methods (get, put, post, put, delete) now take a Regexp as a pattern. Captures are made available to the route block at params[:captures]:

get %r{/foo/(bar|baz)/(\d+)} do
  # assuming: GET /foo/bar/42
  params[:captures]  # => ['bar', 42]
end

Passing on a Route

We added a new request-level pass method that immediately exits the current block and passes control to the next matching route. For example:

get '/shoot/:person' do
  pass unless %w[Kenny Sherrif].include?(params[:person])
  "You shot #{params[:person]}."
end

get '/shoot/*' do
  "Missed!"
end

If no matching route is found after a pass, a NotFound exception is raised and the application 404s as if no route had matched in the first place.

Refined Test Framework

Sinatra’s testing support no longer depends on Test::Unit (or any specific test framework for that matter). Requiring 'sinatra/test' brings in the Sinatra::Test module and the Sinatra::TestHarness class, which can be used as necessary to simulate requests and make assertions about responses.

You can also require sinatra/test/unit, sinatra/test/spec, sinatra/test/rspec, or sinatra/test/bacon to setup a framework-specific testing environment. See the section on “Testing” in the README for examples.

See the CHANGES file for a comprehensive list of enhancements, bug fixes, and deprecations.