This is a fairly large reworking of Sinatra's innards. Although
most of the internal implementation has been modified, it
provides the same basic feature set and is meant to be compatible
with Sinatra 0.3.2.
* The Event and EventContext classes have been removed. Sinatra
applications are now defined within the class context of a
Sinatra::Base subclass; each request is processed within a new
instance.
* Sinatra::Base can be used as a base class for multiple
Rack applications within a single process and can be used as
Rack middleware.
* The routing and result type processing implementation has been
simplified and enhanced a bit. There's a new route conditions
system for things like :agent/:host matching and a request
level #pass method has been added to allow an event handler to
exit immediately, passing control to the next matching route.
* Regular expressions may now be used in route patterns. Captures
are available as an array from "params[:captures]".
* The #body helper method now takes a block. The block is not
evaluated until an attempt is made to read the body.
* Options are now dynamically generated class attributes on the
Sinatra::Base subclass (instead of OpenStruct); options are
inherited by subclasses and may be overridden up the
inheritance hierarchy. The Base.set manages all option related
stuff.
* The application file (app_file) detection heuristics are bit
more sane now. This fixes some bugs with reloading and
public/views directory detection. All thin / passenger issues
of these type should be better now.
* Error mappings are now split into to distinct layers: exception
mappings and custom error pages. Exception mappings are registered
with 'error(Exception)' and are run only when the app raises an
exception. Custom error pages are registered with error(status_code)
and are run any time the response has the status code specified.
It's also possible to register an error page for a range of status
codes: 'error(500..599)'.
* The spec and unit testing extensions have been modified to take
advantage of the ability to have multiple Sinatra applications.
The Sinatra::Test module must be included within the TestCase
in order to take advantage of these methods (unless the
'sinatra/compat' library has been required).
* Rebuilt specs from scratch for better coverage and
organization. Sinatra 3.2 unit tests have been retained
under ./compat to ensure a baseline level of compatibility with
previous versions; use the 'rake compat' task to run these.
A large number of existing Sinatra idioms have been deprecated but
continue to be supported through the 'sinatra/compat' library.
* The "set_option" and "set_options" methods have been deprecated
due to redundancy; use "set".
* The "env" option (Sinatra::Base.env) has been renamed to "environment"
and deprecated because it's too easy to confuse with the request-level
Rack environment Hash (Sinatra::Base#env).
* The request level "stop" method has been renamed "halt" and
deprecated. This is for consistency with `throw :halt`.
* The request level "entity_tag" method has been renamed "etag" and
deprecated. Both versions were previously supported.
* The request level "headers" method has been deprecated. Use
response['Header-Name'] to access and modify response headers.
* Sinatra.application is deprecated. Use Sinatra::Application instead.
* Setting Sinatra.application = nil to reset an application is
deprecated. You shouldn't have to reset objects anymore.
* The Sinatra.default_options Hash is deprecated. Modifying this object now
results in "set(key, value)" invocations on the Sinatra::Base
subclass.
* The "body.to_result" convention has been deprecated.
* The ServerError exception has been deprecated. Any Exception is now
considered a ServerError.
send_file_headers! now accepts nil for :disposition. When nil, omit both
the Content-Disposition and Content-Transfer-Encoding headers.
Modified Static to specify a nil :disposition. I believe this is more
in line with how most web servers serve static directories by default. User
agents are free to choose whether the entity should be displayed inline or
treated as an attachment.
Note that, although files served by the Static handler omit the
Content-Disposition header by default, explicit calls to send_file and
send_data in events default to :disposition => 'attachment'.
Adds support for RFC 2616 conditional requests based on the resources
last modification time. If the request includes an If-Modified-Since
header and the file's last modification time matches the value exactly,
a "304 Not Modified" response is sent (with an empty response body)
instead of the default 200 response with entire response body.
The meat of the implementation is in Streaming#send_file_headers! so
Static and anything else that results in a call to send_file_headers!
gets automatic if-modified-since support.
Implement HEAD by delegating to GET handlers (when no HEAD handler registered)
and removing response body. This fixes a problem where Sinatra sent a 404
response to HEAD requests due to HEAD not having any registered handlers.
While here, make Static handlers respond only to GET and HEAD requests instead
of using GET semantics for PUT/POST/DELETE. Makes it possible for Events to
register PUT/POST/DELETE handlers for static file URLs. For instance, assuming a
file exists, `public/foo.xml`, and the following event:
put '/foo.xml' do
File.open('public/foo.xml', 'wb') do |io|
io.write(request.body.read)
end
''
end
get '/foo.xml' do
"THIS NEVER HAPPENS ... as long as /foo.xml exists on disk."
end
The built-in Static handler hits on GET and the dynamic event hits on PUT. An
important note here is that the Static handler is now registered at the head of
the events[:get] array (see Application#load_default_events! and
Application#lookup), where it was previously a special case in the lookup
method.
