sinatra 0.2.2 → 0.3.0

data/Rakefile

@@ -0,0 +1,111 @@
+require 'rake/clean'
+
+task :default => :test
+
+# SPECS ===============================================================
+
+desc 'Run specs with story style output'
+task :spec do
+  sh 'specrb --specdox -Ilib:test test/*_test.rb'
+end
+
+desc 'Run specs with unit test style output'
+task :test => FileList['test/*_test.rb'] do |t|
+  suite = t.prerequisites.map{|f| "-r#{f.chomp('.rb')}"}.join(' ')
+  sh "ruby -Ilib:test #{suite} -e ''", :verbose => false
+end
+
+# PACKAGING ============================================================
+
+# Load the gemspec using the same limitations as github
+def spec
+  @spec ||=
+    begin
+      require 'rubygems/specification'
+      data = File.read('sinatra.gemspec')
+      spec = nil
+      Thread.new { spec = eval("$SAFE = 3\n#{data}") }.join
+      spec
+    end
+end
+
+def package(ext='')
+  "dist/sinatra-#{spec.version}" + ext
+end
+
+desc 'Build packages'
+task :package => %w[.gem .tar.gz].map {|e| package(e)}
+
+desc 'Build and install as local gem'
+task :install => package('.gem') do
+  sh "gem install #{package('.gem')}"
+end
+
+directory 'dist/'
+
+file package('.gem') => %w[dist/ sinatra.gemspec] + spec.files do |f|
+  sh "gem build sinatra.gemspec"
+  mv File.basename(f.name), f.name
+end
+
+file package('.tar.gz') => %w[dist/] + spec.files do |f|
+  sh "git archive --format=tar HEAD | gzip > #{f.name}"
+end
+
+# Rubyforge Release / Publish Tasks ==================================
+
+desc 'Publish API docs to rubyforge'
+task 'publish:doc' => 'doc/api/index.html' do
+  sh 'scp -rp doc/* rubyforge.org:/var/www/gforge-projects/sinatra/'
+end
+
+task 'publish:gem' => [package('.gem'), package('.tar.gz')] do |t|
+  sh <<-end
+    rubyforge add_release sinatra sinatra #{spec.version} #{package('.gem')} &&
+    rubyforge add_file    sinatra sinatra #{spec.version} #{package('.tar.gz')}
+  end
+end
+
+# Gemspec Helpers ====================================================
+
+file 'sinatra.gemspec' => FileList['{lib,test,images}/**','Rakefile'] do |f|
+  # read spec file and split out manifest section
+  spec = File.read(f.name)
+  parts = spec.split("  # = MANIFEST =\n")
+  fail 'bad spec' if parts.length != 3
+  # determine file list from git ls-files
+  files = `git ls-files`.
+    split("\n").
+    sort.
+    reject{ |file| file =~ /^\./ }.
+    map{ |file| "    #{file}" }.
+    join("\n")
+  # piece file back together and write...
+  parts[1] = "  s.files = %w[\n#{files}\n  ]\n"
+  spec = parts.join("  # = MANIFEST =\n")
+  File.open(f.name, 'w') { |io| io.write(spec) }
+  puts "updated #{f.name}"
+end
+
+# Hanna RDoc =========================================================
+#
+# Building docs requires the hanna gem:
+#   gem install mislav-hanna --source=http://gems.github.com
+
+desc 'Generate Hanna RDoc under doc/api'
+task :doc => ['doc/api/index.html']
+
+file 'doc/api/index.html' => FileList['lib/**/*.rb','README.rdoc'] do |f|
+  rb_files = f.prerequisites
+  sh((<<-end).gsub(/\s+/, ' '))
+    hanna --charset utf8 \
+          --fmt html \
+          --inline-source \
+          --line-numbers \
+          --main README.rdoc \
+          --op doc/api \
+          --title 'Sinatra API Documentation' \
+          #{rb_files.join(' ')}
+  end
+end
+CLEAN.include 'doc/api'

data/lib/sinatra.rb

@@ -1,48 +1,30 @@
-Dir[File.dirname(__FILE__) + "/../vendor/*"].each do |l|
-  $:.unshift "#{File.expand_path(l)}/lib"
-end
-
-require 'rack'
-
-require 'rubygems'
-require 'uri'
 require 'time'
 require 'ostruct'
+require 'uri'
+require 'rack'
 
 if ENV['SWIFT']
  require 'swiftcore/swiftiplied_mongrel'
  puts "Using Swiftiplied Mongrel"
 elsif ENV['EVENT']
-  require 'swiftcore/evented_mongrel' 
+  require 'swiftcore/evented_mongrel'
   puts "Using Evented Mongrel"
 end
 
-class Class
-  def dslify_writer(*syms)
-    syms.each do |sym|
-      class_eval <<-end_eval
-        def #{sym}(v=nil)
-          self.send "#{sym}=", v if v
-          v
-        end
-      end_eval
-    end
-  end
-end
-
 module Rack #:nodoc:
-  
+
   class Request #:nodoc:
 
-    # Set of request method names allowed via the _method parameter hack. By default,
-    # all request methods defined in RFC2616 are included, with the exception of
-    # TRACE and CONNECT.
+    # Set of request method names allowed via the _method parameter hack. By
+    # default, all request methods defined in RFC2616 are included, with the
+    # exception of TRACE and CONNECT.
     POST_TUNNEL_METHODS_ALLOWED = %w( PUT DELETE OPTIONS HEAD )
 
-    # Return the HTTP request method with support for method tunneling using the POST
-    # _method parameter hack.  If the real request method is POST and a _method param is
-    # given and the value is one defined in +POST_TUNNEL_METHODS_ALLOWED+, return the value
-    # of the _method param instead.
+    # Return the HTTP request method with support for method tunneling using
+    # the POST _method parameter hack. If the real request method is POST and
+    # a _method param is given and the value is one defined in
+    # +POST_TUNNEL_METHODS_ALLOWED+, return the value of the _method param
+    # instead.
     def request_method
       if post_tunnel_method_hack?
         params['_method'].upcase
@@ -52,84 +34,87 @@ module Rack #:nodoc:
     end
 
     def user_agent
-      env['HTTP_USER_AGENT']
+      @env['HTTP_USER_AGENT']
     end
 
-    private
-
-      # Return truthfully if and only if the following conditions are met: 1.) the
-      # *actual* request method is POST, 2.) the request content-type is one of
-      # 'application/x-www-form-urlencoded' or 'multipart/form-data', 3.) there is a 
-      # "_method" parameter in the POST body (not in the query string), and 4.) the 
-      # method parameter is one of the verbs listed in the POST_TUNNEL_METHODS_ALLOWED
-      # list.
-      def post_tunnel_method_hack?
-        @env['REQUEST_METHOD'] == 'POST' &&
-          POST_TUNNEL_METHODS_ALLOWED.include?(self.POST.fetch('_method', '').upcase)
-      end
+  private
 
+    # Return truthfully if the request is a valid verb-over-post hack.
+    def post_tunnel_method_hack?
+      @env['REQUEST_METHOD'] == 'POST' &&
+        POST_TUNNEL_METHODS_ALLOWED.include?(self.POST.fetch('_method', '').upcase)
+    end
   end
-  
+
   module Utils
     extend self
   end
 
+  module Handler
+    autoload :Mongrel, ::File.dirname(__FILE__) + "/sinatra/rack/handler/mongrel"
+  end
+
 end
 
+
 module Sinatra
   extend self
 
-  module Version
-    MAJOR = '0'
-    MINOR = '2'
-    REVISION = '2'
-    def self.combined
-      [MAJOR, MINOR, REVISION].join('.')
-    end
-  end
+  VERSION = '0.3.0'
 
-  class NotFound < RuntimeError; end
-  class ServerError < RuntimeError; end
+  class NotFound < RuntimeError
+    def self.code ; 404 ; end
+  end
+  class ServerError < RuntimeError
+    def self.code ; 500 ; end
+  end
 
   Result = Struct.new(:block, :params, :status) unless defined?(Result)
 
   def options
     application.options
   end
-  
+
   def application
-    unless @app 
-      @app = Application.new
-      Sinatra::Environment.setup!
-    end
-    @app
+    @app ||= Application.new
   end
-  
+
   def application=(app)
     @app = app
   end
-  
+
   def port
     application.options.port
   end
-  
+
+  def host
+    application.options.host
+  end
+
   def env
     application.options.env
   end
-  
-  def build_application
-    app = application
-    app = Rack::Session::Cookie.new(app) if Sinatra.options.sessions == true
-    app = Rack::CommonLogger.new(app) if Sinatra.options.logging == true
-    app
+
+  # Deprecated: use application instead of build_application.
+  alias :build_application :application
+
+  def server
+    options.server ||= defined?(Rack::Handler::Thin) ? "thin" : "mongrel"
+
+    # Convert the server into the actual handler name
+    handler = options.server.capitalize
+
+    # If the convenience conversion didn't get us anything,
+    # fall back to what the user actually set.
+    handler = options.server unless Rack::Handler.const_defined?(handler)
+
+    @server ||= eval("Rack::Handler::#{handler}")
   end
-  
+
   def run
-    
     begin
-      puts "== Sinatra has taken the stage on port #{port} for #{env}"
-      require 'pp'
-      Rack::Handler::Mongrel.run(build_application, :Port => port) do |server|
+      puts "== Sinatra/#{Sinatra::VERSION} has taken the stage on port #{port} for #{env} with backup by #{server.name}"
+      server.run(application, {:Port => port, :Host => host}) do |server|
         trap(:INT) do
           server.stop
           puts "\n== Sinatra has ended his set (crowd applauds)"
@@ -138,103 +123,124 @@ module Sinatra
     rescue Errno::EADDRINUSE => e
       puts "== Someone is already performing on port #{port}!"
     end
-    
   end
-      
+
   class Event
+    include Rack::Utils
 
     URI_CHAR = '[^/?:,&#\.]'.freeze unless defined?(URI_CHAR)
-    PARAM = /:(#{URI_CHAR}+)/.freeze unless defined?(PARAM)
+    PARAM = /(:(#{URI_CHAR}+)|\*)/.freeze unless defined?(PARAM)
     SPLAT = /(.*?)/
     attr_reader :path, :block, :param_keys, :pattern, :options
-    
+
     def initialize(path, options = {}, &b)
       @path = URI.encode(path)
       @block = b
       @param_keys = []
       @options = options
-      regex = @path.to_s.gsub(PARAM) do
-        @param_keys << $1
-        "(#{URI_CHAR}+)"
+      splats = 0
+      regex = @path.to_s.gsub(PARAM) do |match|
+        if match == "*"
+          @param_keys << "_splat_#{splats}"
+          splats += 1
+          SPLAT.to_s
+        else
+          @param_keys << $2
+          "(#{URI_CHAR}+)"
+        end
       end
-      
-      regex.gsub!('*', SPLAT.to_s)
-      
+
       @pattern = /^#{regex}$/
     end
-        
+
     def invoke(request)
       params = {}
-      if agent = options[:agent] 
+      if agent = options[:agent]
         return unless request.user_agent =~ agent
         params[:agent] = $~[1..-1]
       end
-      if host = options[:host] 
+      if host = options[:host]
         return unless host === request.host
       end
       return unless pattern =~ request.path_info.squeeze('/')
-      params.merge!(param_keys.zip($~.captures.map(&:from_param)).to_hash)
+      path_params = param_keys.zip($~.captures.map{|s| unescape(s)}).to_hash
+      params.merge!(path_params)
+      splats = params.select { |k, v| k =~ /^_splat_\d+$/ }.sort.map(&:last)
+      unless splats.empty?
+        params.delete_if { |k, v| k =~ /^_splat_\d+$/ }
+        params["splat"] = splats
+      end
       Result.new(block, params, 200)
     end
-    
+
   end
-  
+
   class Error
-    
-    attr_reader :code, :block
-    
-    def initialize(code, &b)
-      @code, @block = code, b
+
+    attr_reader :type, :block, :options
+
+    def initialize(type, options={}, &block)
+      @type = type
+      @block = block
+      @options = options
     end
-    
+
     def invoke(request)
-      Result.new(block, {}, 404)
+      Result.new(block, options, code)
     end
-    
+
+    def code
+      if type.respond_to?(:code)
+        type.code
+      else
+        500
+      end
+    end
+
   end
-  
+
   class Static
-            
+    include Rack::Utils
+
     def invoke(request)
       return unless File.file?(
-        Sinatra.application.options.public + request.path_info
+        Sinatra.application.options.public + unescape(request.path_info)
       )
       Result.new(block, {}, 200)
     end
-    
+
     def block
       Proc.new do
-        send_file Sinatra.application.options.public + request.path_info,
-          :disposition => nil
+        send_file Sinatra.application.options.public +
+          unescape(request.path_info), :disposition => nil
       end
     end
-    
+
   end
-  
-  # Adapted from actionpack
+
   # Methods for sending files and streams to the browser instead of rendering.
   module Streaming
     DEFAULT_SEND_FILE_OPTIONS = {
       :type         => 'application/octet-stream'.freeze,
       :disposition  => 'attachment'.freeze,
-      :stream       => true, 
+      :stream       => true,
       :buffer_size  => 4096
     }.freeze
 
     class MissingFile < RuntimeError; end
 
     class FileStreamer
-      
+
       attr_reader :path, :options
-      
+
       def initialize(path, options)
         @path, @options = path, options
       end
-      
+
       def to_result(cx, *args)
         self
       end
-      
+
       def each
         File.open(path, 'rb') do |file|
           while buf = file.read(options[:buffer_size])
@@ -242,161 +248,281 @@ module Sinatra
           end
         end
       end
-      
-    end
-
-    protected
-      # Sends the file by streaming it 4096 bytes at a time. This way the
-      # whole file doesn't need to be read into memory at once.  This makes
-      # it feasible to send even large files.
-      #
-      # Be careful to sanitize the path parameter if it coming from a web
-      # page.  send_file(params[:path]) allows a malicious user to
-      # download any file on your server.
-      #
-      # Options:
-      # * <tt>:filename</tt> - suggests a filename for the browser to use.
-      #   Defaults to File.basename(path).
-      # * <tt>:type</tt> - specifies an HTTP content type.
-      #   Defaults to 'application/octet-stream'.
-      # * <tt>:disposition</tt> - specifies whether the file will be shown inline or downloaded.  
-      #   Valid values are 'inline' and 'attachment' (default). When set to nil, the
-      #   Content-Disposition and Content-Transfer-Encoding headers are omitted entirely.
-      # * <tt>:stream</tt> - whether to send the file to the user agent as it is read (true)
-      #   or to read the entire file before sending (false). Defaults to true.
-      # * <tt>:buffer_size</tt> - specifies size (in bytes) of the buffer used to stream the file.
-      #   Defaults to 4096.
-      # * <tt>:status</tt> - specifies the status code to send with the response. Defaults to '200 OK'.
-      # * <tt>:last_modified</tt> - an optional RFC 2616 formatted date value (See Time#httpdate)
-      #   indicating the last modified time of the file. If the request includes an
-      #   If-Modified-Since header that matches this value exactly, a 304 Not Modified response
-      #   is sent instead of the file. Defaults to the file's last modified
-      #   time.
-      #
-      # The default Content-Type and Content-Disposition headers are
-      # set to download arbitrary binary files in as many browsers as
-      # possible.  IE versions 4, 5, 5.5, and 6 are all known to have
-      # a variety of quirks (especially when downloading over SSL).
-      #
-      # Simple download:
-      #   send_file '/path/to.zip'
-      #
-      # Show a JPEG in the browser:
-      #   send_file '/path/to.jpeg', :type => 'image/jpeg', :disposition => 'inline'
-      #
-      # Show a 404 page in the browser:
-      #   send_file '/path/to/404.html, :type => 'text/html; charset=utf-8', :status => 404
-      #
-      # Read about the other Content-* HTTP headers if you'd like to
-      # provide the user with more information (such as Content-Description).
-      # http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.11
-      #
-      # Also be aware that the document may be cached by proxies and browsers.
-      # The Pragma and Cache-Control headers declare how the file may be cached
-      # by intermediaries.  They default to require clients to validate with
-      # the server before releasing cached responses.  See
-      # http://www.mnot.net/cache_docs/ for an overview of web caching and
-      # http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.9
-      # for the Cache-Control header spec.
-      def send_file(path, options = {}) #:doc:
-        raise MissingFile, "Cannot read file #{path}" unless File.file?(path) and File.readable?(path)
-
-        options[:length]   ||= File.size(path)
-        options[:filename] ||= File.basename(path)
-        options[:type] ||= Rack::File::MIME_TYPES[File.extname(options[:filename])[1..-1]] || 'text/plain'
-        options[:last_modified] ||= File.mtime(path).httpdate
-        send_file_headers! options
-
-        if options[:stream]
-          throw :halt, [options[:status] || 200, FileStreamer.new(path, options)]
-        else
-          File.open(path, 'rb') { |file| throw :halt, [options[:status] || 200, file.read] }
-        end
-      end
 
-      # Send binary data to the user as a file download.  May set content type, apparent file name,
-      # and specify whether to show data inline or download as an attachment.
-      #
-      # Options:
-      # * <tt>:filename</tt> - Suggests a filename for the browser to use.
-      # * <tt>:type</tt> - specifies an HTTP content type.
-      #   Defaults to 'application/octet-stream'.
-      # * <tt>:disposition</tt> - specifies whether the file will be shown inline or downloaded.  
-      #   Valid values are 'inline' and 'attachment' (default).
-      # * <tt>:status</tt> - specifies the status code to send with the response. Defaults to '200 OK'.
-      # * <tt>:last_modified</tt> - an optional RFC 2616 formatted date value (See Time#httpdate)
-      #   indicating the last modified time of the response entity. If the request includes an
-      #   If-Modified-Since header that matches this value exactly, a 304 Not Modified response
-      #   is sent instead of the data.
-      #
-      # Generic data download:
-      #   send_data buffer
-      #
-      # Download a dynamically-generated tarball:
-      #   send_data generate_tgz('dir'), :filename => 'dir.tgz'
-      #
-      # Display an image Active Record in the browser:
-      #   send_data image.data, :type => image.content_type, :disposition => 'inline'
-      #
-      # See +send_file+ for more information on HTTP Content-* headers and caching.
-      def send_data(data, options = {}) #:doc:
-        send_file_headers! options.merge(:length => data.size)
-        throw :halt, [options[:status] || 200, data]
+    end
+
+  protected
+
+    # Sends the file by streaming it 4096 bytes at a time. This way the
+    # whole file doesn't need to be read into memory at once.  This makes
+    # it feasible to send even large files.
+    #
+    # Be careful to sanitize the path parameter if it coming from a web
+    # page.  send_file(params[:path]) allows a malicious user to
+    # download any file on your server.
+    #
+    # Options:
+    # * <tt>:filename</tt> - suggests a filename for the browser to use.
+    #   Defaults to File.basename(path).
+    # * <tt>:type</tt> - specifies an HTTP content type.
+    #   Defaults to 'application/octet-stream'.
+    # * <tt>:disposition</tt> - specifies whether the file will be shown
+    #   inline or downloaded. Valid values are 'inline' and 'attachment'
+    #   (default). When set to nil, the Content-Disposition and
+    #   Content-Transfer-Encoding headers are omitted entirely.
+    # * <tt>:stream</tt> - whether to send the file to the user agent as it
+    #   is read (true) or to read the entire file before sending (false).
+    #   Defaults to true.
+    # * <tt>:buffer_size</tt> - specifies size (in bytes) of the buffer used
+    #   to stream the file. Defaults to 4096.
+    # * <tt>:status</tt> - specifies the status code to send with the
+    #   response. Defaults to '200 OK'.
+    # * <tt>:last_modified</tt> - an optional RFC 2616 formatted date value
+    #   (See Time#httpdate) indicating the last modified time of the file.
+    #   If the request includes an If-Modified-Since header that matches this
+    #   value exactly, a 304 Not Modified response is sent instead of the file.
+    #   Defaults to the file's last modified time.
+    #
+    # The default Content-Type and Content-Disposition headers are
+    # set to download arbitrary binary files in as many browsers as
+    # possible.  IE versions 4, 5, 5.5, and 6 are all known to have
+    # a variety of quirks (especially when downloading over SSL).
+    #
+    # Simple download:
+    #   send_file '/path/to.zip'
+    #
+    # Show a JPEG in the browser:
+    #   send_file '/path/to.jpeg',
+    #     :type => 'image/jpeg',
+    #     :disposition => 'inline'
+    #
+    # Show a 404 page in the browser:
+    #   send_file '/path/to/404.html,
+    #     :type => 'text/html; charset=utf-8',
+    #     :status => 404
+    #
+    # Read about the other Content-* HTTP headers if you'd like to
+    # provide the user with more information (such as Content-Description).
+    # http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.11
+    #
+    # Also be aware that the document may be cached by proxies and browsers.
+    # The Pragma and Cache-Control headers declare how the file may be cached
+    # by intermediaries.  They default to require clients to validate with
+    # the server before releasing cached responses.  See
+    # http://www.mnot.net/cache_docs/ for an overview of web caching and
+    # http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.9
+    # for the Cache-Control header spec.
+    def send_file(path, options = {}) #:doc:
+      raise MissingFile, "Cannot read file #{path}" unless File.file?(path) and File.readable?(path)
+
+      options[:length]   ||= File.size(path)
+      options[:filename] ||= File.basename(path)
+      options[:type] ||= Rack::File::MIME_TYPES[File.extname(options[:filename])[1..-1]] || 'text/plain'
+      options[:last_modified] ||= File.mtime(path).httpdate
+      send_file_headers! options
+
+      if options[:stream]
+        throw :halt, [options[:status] || 200, FileStreamer.new(path, options)]
+      else
+        File.open(path, 'rb') { |file| throw :halt, [options[:status] || 200, file.read] }
       end
+    end
 
-    private
-      def send_file_headers!(options)
-        options = DEFAULT_SEND_FILE_OPTIONS.merge(options)
-        [:length, :type, :disposition].each do |arg|
-          raise ArgumentError, ":#{arg} option required" unless options.key?(arg)
-        end
+    # Send binary data to the user as a file download. May set content type,
+    # apparent file name, and specify whether to show data inline or download
+    # as an attachment.
+    #
+    # Options:
+    # * <tt>:filename</tt> - Suggests a filename for the browser to use.
+    # * <tt>:type</tt> - specifies an HTTP content type.
+    #   Defaults to 'application/octet-stream'.
+    # * <tt>:disposition</tt> - specifies whether the file will be shown inline
+    #   or downloaded. Valid values are 'inline' and 'attachment' (default).
+    # * <tt>:status</tt> - specifies the status code to send with the response.
+    #   Defaults to '200 OK'.
+    # * <tt>:last_modified</tt> - an optional RFC 2616 formatted date value (See
+    #   Time#httpdate) indicating the last modified time of the response entity.
+    #   If the request includes an If-Modified-Since header that matches this
+    #   value exactly, a 304 Not Modified response is sent instead of the data.
+    #
+    # Generic data download:
+    #   send_data buffer
+    #
+    # Download a dynamically-generated tarball:
+    #   send_data generate_tgz('dir'), :filename => 'dir.tgz'
+    #
+    # Display an image Active Record in the browser:
+    #   send_data image.data,
+    #     :type => image.content_type,
+    #     :disposition => 'inline'
+    #
+    # See +send_file+ for more information on HTTP Content-* headers and caching.
+    def send_data(data, options = {}) #:doc:
+      send_file_headers! options.merge(:length => data.size)
+      throw :halt, [options[:status] || 200, data]
+    end
 
-        # Send a "304 Not Modified" if the last_modified option is provided and matches
-        # the If-Modified-Since request header value.
-        if last_modified = options[:last_modified]
-          header 'Last-Modified' => last_modified
-          throw :halt, [ 304, '' ] if last_modified == request.env['HTTP_IF_MODIFIED_SINCE']
-        end
+  private
 
-        headers(
-          'Content-Length'            => options[:length].to_s,
-          'Content-Type'              => options[:type].strip  # fixes a problem with extra '\r' with some browsers
-        )
-
-        # Omit Content-Disposition and Content-Transfer-Encoding headers if
-        # the :disposition option set to nil.
-        if !options[:disposition].nil?
-          disposition = options[:disposition].dup || 'attachment'
-          disposition <<= %(; filename="#{options[:filename]}") if options[:filename]
-          headers 'Content-Disposition' => disposition, 'Content-Transfer-Encoding' => 'binary'
-        end
+    def send_file_headers!(options)
+      options = DEFAULT_SEND_FILE_OPTIONS.merge(options)
+      [:length, :type, :disposition].each do |arg|
+        raise ArgumentError, ":#{arg} option required" unless options.key?(arg)
+      end
 
-        # Fix a problem with IE 6.0 on opening downloaded files:
-        # If Cache-Control: no-cache is set (which Rails does by default), 
-        # IE removes the file it just downloaded from its cache immediately 
-        # after it displays the "open/save" dialog, which means that if you 
-        # hit "open" the file isn't there anymore when the application that 
-        # is called for handling the download is run, so let's workaround that
-        header('Cache-Control' => 'private') if headers['Cache-Control'] == 'no-cache'
+      # Send a "304 Not Modified" if the last_modified option is provided and
+      # matches the If-Modified-Since request header value.
+      if last_modified = options[:last_modified]
+        header 'Last-Modified' => last_modified
+        throw :halt, [ 304, '' ] if last_modified == request.env['HTTP_IF_MODIFIED_SINCE']
       end
+
+      headers(
+        'Content-Length'            => options[:length].to_s,
+        'Content-Type'              => options[:type].strip  # fixes a problem with extra '\r' with some browsers
+      )
+
+      # Omit Content-Disposition and Content-Transfer-Encoding headers if
+      # the :disposition option set to nil.
+      if !options[:disposition].nil?
+        disposition = options[:disposition].dup || 'attachment'
+        disposition <<= %(; filename="#{options[:filename]}") if options[:filename]
+        headers 'Content-Disposition' => disposition, 'Content-Transfer-Encoding' => 'binary'
+      end
+
+      # Fix a problem with IE 6.0 on opening downloaded files:
+      # If Cache-Control: no-cache is set (which Rails does by default),
+      # IE removes the file it just downloaded from its cache immediately
+      # after it displays the "open/save" dialog, which means that if you
+      # hit "open" the file isn't there anymore when the application that
+      # is called for handling the download is run, so let's workaround that
+      header('Cache-Control' => 'private') if headers['Cache-Control'] == 'no-cache'
+    end
   end
-  
+
+
+  # Helper methods for building various aspects of the HTTP response.
   module ResponseHelpers
 
+    # Immediately halt response execution by redirecting to the resource
+    # specified. The +path+ argument may be an absolute URL or a path
+    # relative to the site root. Additional arguments are passed to the
+    # halt.
+    #
+    # With no integer status code, a '302 Temporary Redirect' response is
+    # sent. To send a permanent redirect, pass an explicit status code of
+    # 301:
+    #
+    #   redirect '/somewhere/else', 301
+    #
+    # NOTE: No attempt is made to rewrite the path based on application
+    # context. The 'Location' response header is set verbatim to the value
+    # provided.
     def redirect(path, *args)
       status(302)
-      headers 'Location' => path
+      header 'Location' => path
       throw :halt, *args
     end
-    
+
+    # Access or modify response headers. With no argument, return the
+    # underlying headers Hash. With a Hash argument, add or overwrite
+    # existing response headers with the values provided:
+    #
+    #    headers 'Content-Type' => "text/html;charset=utf-8",
+    #      'Last-Modified' => Time.now.httpdate,
+    #      'X-UA-Compatible' => 'IE=edge'
+    #
+    # This method also available in singular form (#header).
     def headers(header = nil)
       @response.headers.merge!(header) if header
       @response.headers
     end
     alias :header :headers
 
+    # Set the content type of the response body (HTTP 'Content-Type' header).
+    #
+    # The +type+ argument may be an internet media type (e.g., 'text/html',
+    # 'application/xml+atom', 'image/png') or a Symbol key into the
+    # Rack::File::MIME_TYPES table.
+    #
+    # Media type parameters, such as "charset", may also be specified using the
+    # optional hash argument:
+    #
+    #   get '/foo.html' do
+    #     content_type 'text/html', :charset => 'utf-8'
+    #     "<h1>Hello World</h1>"
+    #   end
+    #
+    def content_type(type, params={})
+      type = Rack::File::MIME_TYPES[type.to_s] if type.kind_of?(Symbol)
+      fail "Invalid or undefined media_type: #{type}" if type.nil?
+      if params.any?
+        params = params.collect { |kv| "%s=%s" % kv }.join(', ')
+        type = [ type, params ].join(";")
+      end
+      response.header['Content-Type'] = type
+    end
+
+    # Set the last modified time of the resource (HTTP 'Last-Modified' header)
+    # and halt if conditional GET matches. The +time+ argument is a Time,
+    # DateTime, or other object that responds to +to_time+.
+    #
+    # When the current request includes an 'If-Modified-Since' header that
+    # matches the time specified, execution is immediately halted with a
+    # '304 Not Modified' response.
+    #
+    # Calling this method before perfoming heavy processing (e.g., lengthy
+    # database queries, template rendering, complex logic) can dramatically
+    # increase overall throughput with caching clients.
+    def last_modified(time)
+      time = time.to_time if time.respond_to?(:to_time)
+      time = time.httpdate if time.respond_to?(:httpdate)
+      response.header['Last-Modified'] = time
+      throw :halt, 304 if time == request.env['HTTP_IF_MODIFIED_SINCE']
+      time
+    end
+
+    # Set the response entity tag (HTTP 'ETag' header) and halt if conditional
+    # GET matches. The +value+ argument is an identifier that uniquely
+    # identifies the current version of the resource. The +strength+ argument
+    # indicates whether the etag should be used as a :strong (default) or :weak
+    # cache validator.
+    #
+    # When the current request includes an 'If-None-Match' header with a
+    # matching etag, execution is immediately halted. If the request method is
+    # GET or HEAD, a '304 Not Modified' response is sent. For all other request
+    # methods, a '412 Precondition Failed' response is sent.
+    #
+    # Calling this method before perfoming heavy processing (e.g., lengthy
+    # database queries, template rendering, complex logic) can dramatically
+    # increase overall throughput with caching clients.
+    #
+    # ==== See Also
+    # {RFC2616: ETag}[http://w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.19],
+    # ResponseHelpers#last_modified
+    def entity_tag(value, strength=:strong)
+      value =
+        case strength
+        when :strong then '"%s"' % value
+        when :weak   then 'W/"%s"' % value
+        else         raise TypeError, "strength must be one of :strong or :weak"
+        end
+      response.header['ETag'] = value
+
+      # Check for If-None-Match request header and halt if match is found.
+      etags = (request.env['HTTP_IF_NONE_MATCH'] || '').split(/\s*,\s*/)
+      if etags.include?(value) || etags.include?('*')
+        # GET/HEAD requests: send Not Modified response
+        throw :halt, 304 if request.get? || request.head?
+        # Other requests: send Precondition Failed response
+        throw :halt, 412
+      end
+    end
+
+    alias :etag :entity_tag
+
   end
-  
+
   module RenderingHelpers
 
     def render(renderer, template, options={})
@@ -407,90 +533,104 @@ module Sinatra
       end
       result
     end
-    
+
     def determine_layout(renderer, template, options)
       return if options[:layout] == false
       layout_from_options = options[:layout] || :layout
       resolve_template(renderer, layout_from_options, options, false)
     end
 
-    private
-        
-      def resolve_template(renderer, template, options, scream = true)
-        case template
-        when String
-          template
-        when Proc
-          template.call
-        when Symbol
-          if proc = templates[template]
-            resolve_template(renderer, proc, options, scream)
-          else
-            read_template_file(renderer, template, options, scream)
-          end
+  private
+
+    def resolve_template(renderer, template, options, scream = true)
+      case template
+      when String
+        template
+      when Proc
+        template.call
+      when Symbol
+        if proc = templates[template]
+          resolve_template(renderer, proc, options, scream)
         else
-          nil
-        end
-      end
-      
-      def read_template_file(renderer, template, options, scream = true)
-        path = File.join(
-          options[:views_directory] || Sinatra.application.options.views,
-          "#{template}.#{renderer}"
-        )
-        unless File.exists?(path)
-          raise Errno::ENOENT.new(path) if scream
-          nil
-        else  
-          File.read(path)
+          read_template_file(renderer, template, options, scream)
         end
+      else
+        nil
       end
-      
-      def templates
-        Sinatra.application.templates
+    end
+
+    def read_template_file(renderer, template, options, scream = true)
+      path = File.join(
+        options[:views_directory] || Sinatra.application.options.views,
+        "#{template}.#{renderer}"
+      )
+      unless File.exists?(path)
+        raise Errno::ENOENT.new(path) if scream
+        nil
+      else
+        File.read(path)
       end
-    
+    end
+
+    def templates
+      Sinatra.application.templates
+    end
+
   end
 
   module Erb
-    
+
     def erb(content, options={})
       require 'erb'
       render(:erb, content, options)
     end
-    
-    private 
-    
-      def render_erb(content, options = {})
-        ::ERB.new(content).result(binding)
+
+  private
+
+    def render_erb(content, options = {})
+      locals_opt = options.delete(:locals) || {}
+
+      locals_code = ""
+      locals_hash = {}
+      locals_opt.each do |key, value|
+        locals_code << "#{key} = locals_hash[:#{key}]\n"
+        locals_hash[:"#{key}"] = value
       end
-      
+
+      body = ::ERB.new(content).src
+      eval("#{locals_code}#{body}", binding)
+    end
+
   end
 
   module Haml
-    
+
     def haml(content, options={})
       require 'haml'
       render(:haml, content, options)
     end
-    
-    private
-    
-      def render_haml(content, options = {}, &b)
-        ::Haml::Engine.new(content).render(options[:scope] || self, options[:locals] || {}, &b)
-      end
-        
+
+  private
+
+    def render_haml(content, options = {}, &b)
+      haml_options = (options[:options] || {}).
+        merge(Sinatra.options.haml || {})
+      ::Haml::Engine.new(content, haml_options).
+        render(options[:scope] || self, options[:locals] || {}, &b)
+    end
+
   end
 
   # Generate valid CSS using Sass (part of Haml)
   #
-  # Sass templates can be in external files with <tt>.sass</tt> extension or can use Sinatra's
-  # in_file_templates.  In either case, the file can be rendered by passing the name of
-  # the template to the +sass+ method as a symbol.
+  # Sass templates can be in external files with <tt>.sass</tt> extension
+  # or can use Sinatra's in_file_templates.  In either case, the file can
+  # be rendered by passing the name of the template to the +sass+ method
+  # as a symbol.
   #
-  # Unlike Haml, Sass does not support a layout file, so the +sass+ method will ignore both
-  # the default <tt>layout.sass</tt> file and any parameters passed in as <tt>:layout</tt> in
-  # the options hash.
+  # Unlike Haml, Sass does not support a layout file, so the +sass+ method
+  # will ignore both the default <tt>layout.sass</tt> file and any parameters
+  # passed in as <tt>:layout</tt> in the options hash.
   #
   # === Sass Template Files
   #
@@ -504,7 +644,7 @@ module Sinatra
   #   end
   #
   # The "views/stylesheet.sass" file might contain the following:
-  #  
+  #
   #  body
   #    #admin
   #      :background-color #CCC
@@ -520,51 +660,50 @@ module Sinatra
   #     background-color: #CCC; }
   #   body #main {
   #     background-color: #000; }
-  #   
+  #
   #   #form {
   #     border-color: #AAA;
   #     border-width: 10px; }
-  #   
+  #
   #
   # NOTE: Haml must be installed or a LoadError will be raised the first time an
   # attempt is made to render a Sass template.
   #
   # See http://haml.hamptoncatlin.com/docs/rdoc/classes/Sass.html for comprehensive documentation on Sass.
-
-  
   module Sass
-    
+
     def sass(content, options = {})
       require 'sass'
-      
+
       # Sass doesn't support a layout, so we override any possible layout here
       options[:layout] = false
-      
+
       render(:sass, content, options)
     end
-    
-    private
-      
-      def render_sass(content, options = {})
-        ::Sass::Engine.new(content).render
-      end
+
+  private
+
+    def render_sass(content, options = {})
+      ::Sass::Engine.new(content).render
+    end
+
   end
 
   # Generating conservative XML content using Builder templates.
   #
-  # Builder templates can be inline by passing a block to the builder method, or in
-  # external files with +.builder+ extension by passing the name of the template
-  # to the +builder+ method as a Symbol.
+  # Builder templates can be inline by passing a block to the builder method,
+  # or in external files with +.builder+ extension by passing the name of the
+  # template to the +builder+ method as a Symbol.
   #
   # === Inline Rendering
   #
-  # If the builder method is given a block, the block is called directly with an 
-  # +XmlMarkup+ instance and the result is returned as String:
+  # If the builder method is given a block, the block is called directly with
+  # an +XmlMarkup+ instance and the result is returned as String:
   #   get '/who.xml' do
   #     builder do |xml|
   #       xml.instruct!
   #       xml.person do
-  #         xml.name "Francis Albert Sinatra", 
+  #         xml.name "Francis Albert Sinatra",
   #           :aka => "Frank Sinatra"
   #         xml.email 'frank@capitolrecords.com'
   #       end
@@ -580,9 +719,9 @@ module Sinatra
   #
   # === Builder Template Files
   #
-  # Builder templates can be stored in separate files with a +.builder+ 
-  # extension under the view path. An +XmlMarkup+ object named +xml+ is automatically
-  # made available to template.
+  # Builder templates can be stored in separate files with a +.builder+
+  # extension under the view path. An +XmlMarkup+ object named +xml+ is
+  # automatically made available to template.
   #
   # Example:
   #   get '/bio.xml' do
@@ -613,10 +752,11 @@ module Sinatra
   #     <died age='82' />
   #   </person>
   #
-  # NOTE: Builder must be installed or a LoadError will be raised the first time an
-  # attempt is made to render a builder template.
+  # NOTE: Builder must be installed or a LoadError will be raised the first
+  # time an attempt is made to render a builder template.
   #
-  # See http://builder.rubyforge.org/ for comprehensive documentation on Builder.
+  # See http://builder.rubyforge.org/ for comprehensive documentation on
+  # Builder.
   module Builder
 
     def builder(content=nil, options={}, &block)
@@ -625,24 +765,24 @@ module Sinatra
       render(:builder, content, options)
     end
 
-    private
+  private
 
-      def render_builder(content, options = {}, &b)
-        require 'builder'
-        xml = ::Builder::XmlMarkup.new(:indent => 2)
-        case content
-        when String
-          eval(content, binding, '<BUILDER>', 1)
-        when Proc
-          content.call(xml)
-        end
-        xml.target!
+    def render_builder(content, options = {}, &b)
+      require 'builder'
+      xml = ::Builder::XmlMarkup.new(:indent => 2)
+      case content
+      when String
+        eval(content, binding, '<BUILDER>', 1)
+      when Proc
+        content.call(xml)
       end
+      xml.target!
+    end
 
   end
 
   class EventContext
-    
+    include Rack::Utils
     include ResponseHelpers
     include Streaming
     include RenderingHelpers
@@ -650,119 +790,280 @@ module Sinatra
     include Haml
     include Builder
     include Sass
-    
+
     attr_accessor :request, :response
-    
-    dslify_writer :status, :body
-    
+
+    attr_accessor :route_params
+
     def initialize(request, response, route_params)
+      @params = nil
+      @data = nil
       @request = request
       @response = response
       @route_params = route_params
       @response.body = nil
     end
-    
+
+    def status(value=nil)
+      response.status = value if value
+      response.status
+    end
+
+    def body(value=nil)
+      response.body = value if value
+      response.body
+    end
+
     def params
-      @params ||= begin 
-        h = Hash.new {|h,k| h[k.to_s] if Symbol === k}
-        h.merge(@route_params.merge(@request.params))
-      end
+      @params ||=
+        begin
+          hash = Hash.new {|h,k| h[k.to_s] if Symbol === k}
+          hash.merge! @request.params
+          hash.merge! @route_params
+          hash
+        end
     end
 
     def data
       @data ||= params.keys.first
     end
-    
+
     def stop(*args)
       throw :halt, args
     end
-    
+
     def complete(returned)
       @response.body || returned
     end
-    
+
     def session
-      @request.env['rack.session'] || {}
+      request.env['rack.session'] ||= {}
+    end
+
+    def reset!
+      @params = nil
+      @data = nil
     end
-    
-    private
 
-      def method_missing(name, *args, &b)
+  private
+
+    def method_missing(name, *args, &b)
+      if @response.respond_to?(name)
         @response.send(name, *args, &b)
+      else
+        super
       end
-    
+    end
+
   end
-  
+
+
+  # The Application class represents the top-level working area of a
+  # Sinatra app. It provides the DSL for defining various aspects of the
+  # application and implements a Rack compatible interface for dispatching
+  # requests.
+  #
+  # Many of the instance methods defined in this class (#get, #post,
+  # #put, #delete, #layout, #before, #error, #not_found, etc.) are
+  # available at top-level scope. When invoked from top-level, the
+  # messages are forwarded to the "default application" (accessible
+  # at Sinatra::application).
   class Application
-    
-    attr_reader :events, :errors, :templates, :filters
-    attr_reader :clearables, :reloading
-    
-    attr_writer :options
-    
+
+    # Hash of event handlers with request method keys and
+    # arrays of potential handlers as values.
+    attr_reader :events
+
+    # Hash of error handlers with error status codes as keys and
+    # handlers as values.
+    attr_reader :errors
+
+    # Hash of template name mappings.
+    attr_reader :templates
+
+    # Hash of filters with event name keys (:before) and arrays of
+    # handlers as values.
+    attr_reader :filters
+
+    # Array of objects to clear during reload. The objects in this array
+    # must respond to :clear.
+    attr_reader :clearables
+
+    # Object including open attribute methods for modifying Application
+    # configuration.
+    attr_reader :options
+
+    # List of methods available from top-level scope. When invoked from
+    # top-level the method is forwarded to the default application
+    # (Sinatra::application).
+    FORWARD_METHODS = %w[
+      get put post delete head template layout before error not_found
+      configures configure set set_options set_option enable disable use
+      development? test? production?
+    ]
+
+    # Create a new Application with a default configuration taken
+    # from the default_options Hash.
+    #
+    # NOTE: A default Application is automatically created the first
+    # time any of Sinatra's DSL related methods is invoked so there
+    # is typically no need to create an instance explicitly. See
+    # Sinatra::application for more information.
+    def initialize
+      @reloading = false
+      @clearables = [
+        @events = Hash.new { |hash, key| hash[key] = [] },
+        @errors = Hash.new,
+        @filters = Hash.new { |hash, key| hash[key] = [] },
+        @templates = Hash.new,
+        @middleware = []
+      ]
+      @options = OpenStruct.new(self.class.default_options)
+      load_default_configuration!
+    end
+
+    # Hash of default application configuration options. When a new
+    # Application is created, the #options object takes its initial values
+    # from here.
+    #
+    # Changes to the default_options Hash effect only Application objects
+    # created after the changes are made. For this reason, modifications to
+    # the default_options Hash typically occur at the very beginning of a
+    # file, before any DSL related functions are invoked.
     def self.default_options
-      @@default_options ||= {
+      return @default_options unless @default_options.nil?
+      root = File.expand_path(File.dirname($0))
+      @default_options = {
         :run => true,
         :port => 4567,
+        :host => '0.0.0.0',
         :env => :development,
-        :root => Dir.pwd,
-        :views => Dir.pwd + '/views',
-        :public => Dir.pwd + '/public',
+        :root => root,
+        :views => root + '/views',
+        :public => root + '/public',
         :sessions => false,
         :logging => true,
+        :app_file => $0,
+        :raise_errors => false
       }
-    end
-    
-    def default_options
-      self.class.default_options
+      load_default_options_from_command_line!
+      @default_options
     end
 
-    
-    ##
-    # Load all options given on the command line
+    # Search ARGV for command line arguments and update the
+    # Sinatra::default_options Hash accordingly. This method is
+    # invoked the first time the default_options Hash is accessed.
     # NOTE:  Ignores --name so unit/spec tests can run individually
-    def load_options!
+    def self.load_default_options_from_command_line! #:nodoc:
+      # fixes issue with: gem install --test sinatra
+      return if ARGV.empty? || File.basename($0) =~ /gem/
       require 'optparse'
       OptionParser.new do |op|
         op.on('-p port') { |port| default_options[:port] = port }
-        op.on('-e env') { |env| default_options[:env] = env }
-        op.on('-x') { |env| default_options[:mutex] = true }
+        op.on('-e env') { |env| default_options[:env] = env.to_sym }
+        op.on('-x') { default_options[:mutex] = true }
+        op.on('-s server') { |server| default_options[:server] = server }
       end.parse!(ARGV.dup.select { |o| o !~ /--name/ })
     end
 
-    # Called immediately after the application is initialized or reloaded to
-    # register default events. Events added here have dibs on requests since
-    # they appear first in the list.
-    def load_default_events!
-      events[:get] << Static.new
+    # Determine whether the application is in the process of being
+    # reloaded.
+    def reloading?
+      @reloading == true
     end
 
-    def initialize
-      @clearables = [
-        @events = Hash.new { |hash, key| hash[key] = [] },
-        @errors = Hash.new,
-        @filters = Hash.new { |hash, key| hash[key] = [] },
-        @templates = Hash.new
-      ]
-      load_options!
-      load_default_events!
+    # Yield to the block for configuration if the current environment
+    # matches any included in the +envs+ list. Always yield to the block
+    # when no environment is specified.
+    #
+    # NOTE: configuration blocks are not executed during reloads.
+    def configures(*envs, &b)
+      return if reloading?
+      yield self if envs.empty? || envs.include?(options.env)
+    end
+
+    alias :configure :configures
+
+    # When both +option+ and +value+ arguments are provided, set the option
+    # specified. With a single Hash argument, set all options specified in
+    # Hash. Options are available via the Application#options object.
+    #
+    # Setting individual options:
+    #   set :port, 80
+    #   set :env, :production
+    #   set :views, '/path/to/views'
+    #
+    # Setting multiple options:
+    #   set :port  => 80,
+    #       :env   => :production,
+    #       :views => '/path/to/views'
+    #
+    def set(option, value=self)
+      if value == self && option.kind_of?(Hash)
+        option.each { |key,val| set(key, val) }
+      else
+        options.send("#{option}=", value)
+      end
     end
 
-    def define_event(method, path, options = {}, &b)
-      events[method] << event = Event.new(path, options, &b)
-      event
+    alias :set_option :set
+    alias :set_options :set
+
+    # Enable the options specified by setting their values to true. For
+    # example, to enable sessions and logging:
+    #   enable :sessions, :logging
+    def enable(*opts)
+      opts.each { |key| set(key, true) }
     end
-    
-    def define_template(name=:layout, &b)
-      templates[name] = b
+
+    # Disable the options specified by setting their values to false. For
+    # example, to disable logging and automatic run:
+    #   disable :logging, :run
+    def disable(*opts)
+      opts.each { |key| set(key, false) }
+    end
+
+    # Define an event handler for the given request method and path
+    # spec. The block is executed when a request matches the method
+    # and spec.
+    #
+    # NOTE: The #get, #post, #put, and #delete helper methods should
+    # be used to define events when possible.
+    def event(method, path, options = {}, &b)
+      events[method].push(Event.new(path, options, &b)).last
+    end
+
+    # Define an event handler for GET requests.
+    def get(path, options={}, &b)
+      event(:get, path, options, &b)
     end
-    
-    def define_error(code, options = {}, &b)
-      errors[code] = Error.new(code, &b)
+
+    # Define an event handler for POST requests.
+    def post(path, options={}, &b)
+      event(:post, path, options, &b)
     end
-    
-    def define_filter(type, &b)
-      filters[:before] << b
+
+    # Define an event handler for HEAD requests.
+    def head(path, options={}, &b)
+      event(:head, path, options, &b)
+    end
+
+    # Define an event handler for PUT requests.
+    #
+    # NOTE: PUT events are triggered when the HTTP request method is
+    # PUT and also when the request method is POST and the body includes a
+    # "_method" parameter set to "PUT".
+    def put(path, options={}, &b)
+      event(:put, path, options, &b)
+    end
+
+    # Define an event handler for DELETE requests.
+    #
+    # NOTE: DELETE events are triggered when the HTTP request method is
+    # DELETE and also when the request method is POST and the body includes a
+    # "_method" parameter set to "DELETE".
+    def delete(path, options={}, &b)
+      event(:delete, path, options, &b)
     end
 
     # Visits and invokes each handler registered for the +request_method+ in
@@ -780,224 +1081,305 @@ module Sinatra
         errors[NotFound].invoke(request)
     end
 
-    def options
-      @options ||= OpenStruct.new(default_options)
+    # Define a named template. The template may be referenced from
+    # event handlers by passing the name as a Symbol to rendering
+    # methods. The block is executed each time the template is rendered
+    # and the resulting object is passed to the template handler.
+    #
+    # The following example defines a HAML template named hello and
+    # invokes it from an event handler:
+    #
+    #   template :hello do
+    #     "h1 Hello World!"
+    #   end
+    #
+    #   get '/' do
+    #     haml :hello
+    #   end
+    #
+    def template(name, &b)
+      templates[name] = b
     end
-    
-    def development?
-      options.env == :development
+
+    # Define a layout template.
+    def layout(name=:layout, &b)
+      template(name, &b)
+    end
+
+    # Define a custom error handler for the exception class +type+. The block
+    # is invoked when the specified exception type is raised from an error
+    # handler and can manipulate the response as needed:
+    #
+    #   error MyCustomError do
+    #     status 500
+    #     'So what happened was...' + request.env['sinatra.error'].message
+    #   end
+    #
+    # The Sinatra::ServerError handler is used by default when an exception
+    # occurs and no matching error handler is found.
+    def error(type=ServerError, options = {}, &b)
+      errors[type] = Error.new(type, options, &b)
     end
 
+    # Define a custom error handler for '404 Not Found' responses. This is a
+    # shorthand for:
+    #   error NotFound do
+    #     ..
+    #   end
+    def not_found(options={}, &b)
+      error NotFound, options, &b
+    end
+
+    # Define a request filter. When <tt>type</tt> is <tt>:before</tt>, execute the
+    # block in the context of each request before matching event handlers.
+    def filter(type, &b)
+      filters[type] << b
+    end
+
+    # Invoke the block in the context of each request before invoking
+    # matching event handlers.
+    def before(&b)
+      filter :before, &b
+    end
+
+    # True when environment is :development.
+    def development? ; options.env == :development ; end
+
+    # True when environment is :test.
+    def test? ; options.env == :test ; end
+
+    # True when environment is :production.
+    def production? ; options.env == :production ; end
+
+    # Clear all events, templates, filters, and error handlers
+    # and then reload the application source file. This occurs
+    # automatically before each request is processed in development.
     def reload!
-      @reloading = true
       clearables.each(&:clear)
-      load_default_events!
-      Kernel.load $0
+      load_default_configuration!
+      load_development_configuration! if development?
+      @pipeline = nil
+      @reloading = true
+      Kernel.load options.app_file
       @reloading = false
-      Environment.setup!
     end
-    
+
+    # Determine whether the application is in the process of being
+    # reloaded.
+    def reloading?
+      @reloading == true
+    end
+
+    # Mutex instance used for thread synchronization.
     def mutex
       @@mutex ||= Mutex.new
     end
-    
+
+    # Yield to the block with thread synchronization
     def run_safely
-      if options.mutex
+      if development? || options.mutex
         mutex.synchronize { yield }
       else
         yield
       end
     end
-    
+
+    # Add a piece of Rack middleware to the pipeline leading to the
+    # application.
+    def use(klass, *args, &block)
+      fail "#{klass} must respond to 'new'" unless klass.respond_to?(:new)
+      @pipeline = nil
+      @middleware.push([ klass, args, block ]).last
+    end
+
+  private
+
+    # Rack middleware derived from current state of application options.
+    # These components are plumbed in at the very beginning of the
+    # pipeline.
+    def optional_middleware
+      [
+        ([ Rack::CommonLogger,    [], nil ] if options.logging),
+        ([ Rack::Session::Cookie, [], nil ] if options.sessions)
+      ].compact
+    end
+
+    # Rack middleware explicitly added to the application with #use. These
+    # components are plumbed into the pipeline downstream from
+    # #optional_middle.
+    def explicit_middleware
+      @middleware
+    end
+
+    # All Rack middleware used to construct the pipeline.
+    def middleware
+      optional_middleware + explicit_middleware
+    end
+
+  public
+
+    # An assembled pipeline of Rack middleware that leads eventually to
+    # the Application#invoke method. The pipeline is built upon first
+    # access. Defining new middleware with Application#use or manipulating
+    # application options may cause the pipeline to be rebuilt.
+    def pipeline
+      @pipeline ||=
+        middleware.inject(method(:dispatch)) do |app,(klass,args,block)|
+          klass.new(app, *args, &block)
+        end
+    end
+
+    # Rack compatible request invocation interface.
     def call(env)
-      reload! if development?
+      run_safely do
+        reload! if development? && (options.reload != false)
+        pipeline.call(env)
+      end
+    end
+
+    # Request invocation handler - called at the end of the Rack pipeline
+    # for each request.
+    #
+    # 1. Create Rack::Request, Rack::Response helper objects.
+    # 2. Lookup event handler based on request method and path.
+    # 3. Create new EventContext to house event handler evaluation.
+    # 4. Invoke each #before filter in context of EventContext object.
+    # 5. Invoke event handler in context of EventContext object.
+    # 6. Return response to Rack.
+    #
+    # See the Rack specification for detailed information on the
+    # +env+ argument and return value.
+    def dispatch(env)
       request = Rack::Request.new(env)
-      result = lookup(request)
-      context = EventContext.new(
-        request, 
-        Rack::Response.new,
-        result.params
-      )
-      context.status(result.status)
+      context = EventContext.new(request, Rack::Response.new([], 200), {})
       begin
-        returned = run_safely do
+        returned =
           catch(:halt) do
             filters[:before].each { |f| context.instance_eval(&f) }
+            result = lookup(context.request)
+            context.route_params = result.params
+            context.response.status = result.status
+            context.reset!
             [:complete, context.instance_eval(&result.block)]
           end
-        end
         body = returned.to_result(context)
       rescue => e
         request.env['sinatra.error'] = e
         context.status(500)
+        raise if options.raise_errors && e.class != NotFound
         result = (errors[e.class] || errors[ServerError]).invoke(request)
-        returned = run_safely do
+        returned =
           catch(:halt) do
             [:complete, context.instance_eval(&result.block)]
           end
-        end
         body = returned.to_result(context)
       end
       body = '' unless body.respond_to?(:each)
-      body = '' if request.request_method.upcase == 'HEAD'
+      body = '' if request.env["REQUEST_METHOD"].upcase == 'HEAD'
       context.body = body.kind_of?(String) ? [*body] : body
       context.finish
     end
-    
-  end
-  
-  
-  module Environment
-    extend self
-    
-    def setup!
+
+  private
+
+    # Called immediately after the application is initialized or reloaded to
+    # register default events, templates, and error handlers.
+    def load_default_configuration!
+      events[:get] << Static.new
       configure do
         error do
-          raise request.env['sinatra.error'] if Sinatra.options.raise_errors
           '<h1>Internal Server Error</h1>'
         end
         not_found { '<h1>Not Found</h1>'}
       end
-      
-      configures :development do
+    end
 
-        get '/sinatra_custom_images/:image.png' do
-          File.read(File.dirname(__FILE__) + "/../images/#{params[:image]}.png")
-        end
+    # Called before reloading to perform development specific configuration.
+    def load_development_configuration!
+      get '/sinatra_custom_images/:image.png' do
+        content_type :png
+        File.read(File.dirname(__FILE__) + "/../images/#{params[:image]}.png")
+      end
 
-        not_found do
-          %Q(
-          <style>
-          body {
-            text-align: center; 
-            color: #888;
-            font-family: Arial; 
-            font-size: 22px; 
-            margin: 20px;
-          }
-          #content {
-            margin: 0 auto;
-            width: 500px;
-            text-align: left;
-          }
-          </style>
-          <html>
-            <body>
-              <h2>Sinatra doesn't know this diddy.</h2>
-              <img src='/sinatra_custom_images/404.png'></img>
-              <div id="content">
-                Try this:
-<pre>#{request.request_method.downcase} "#{request.path_info}" do
-  .. do something ..
-end<pre>
-              </div>
-            </body>
-          </html>
-          )
-        end
+      not_found do
+        (<<-HTML).gsub(/^ {8}/, '')
+        <!DOCTYPE html>
+        <html>
+          <head>
+            <style type="text/css">
+            body {text-align:center;color:#888;font-family:arial;font-size:22px;margin:20px;}
+            #content {margin:0 auto;width:500px;text-align:left}
+            </style>
+          </head>
+          <body>
+            <h2>Sinatra doesn't know this diddy.</h2>
+            <img src='/sinatra_custom_images/404.png'>
+            <div id="content">
+              Try this:
+              <pre>#{request.request_method.downcase} "#{request.path_info}" do\n  .. do something ..\nend<pre>
+            </div>
+          </body>
+        </html>
+        HTML
+      end
 
-        error do
-          @error = request.env['sinatra.error']
-          %Q(
-          <html>
-          	<body>
-          		<style type="text/css" media="screen">
-          			body {
-          				font-family: Verdana;
-          				color: #333;
-          			}
-
-          			#content {
-          				width: 700px;
-          				margin-left: 20px;
-          			}
-
-          			#content h1 {
-          				width: 99%;
-          				color: #1D6B8D;
-          				font-weight: bold;
-          			}
-
-          			#stacktrace {
-          			  margin-top: -20px;
-          			}
-
-          			#stacktrace pre {
-          				font-size: 12px;
-          				border-left: 2px solid #ddd;
-          				padding-left: 10px;
-          			}
-
-          			#stacktrace img {
-          				margin-top: 10px;
-          			}
-          		</style>
-          		<div id="content">
-            		<img src="/sinatra_custom_images/500.png" />
-            		<div class="info">
-                  Params: <pre>#{params.inspect}
-            		</div>
-          			<div id="stacktrace">
-          				<h1>#{Rack::Utils.escape_html(@error.class.name + ' - ' + @error.message)}</h1>
-          				<pre><code>#{Rack::Utils.escape_html(@error.backtrace.join("\n"))}</code></pre>
-          		</div>
-          	</body>
-          </html>
-          )
-        end
+      error do
+        @error = request.env['sinatra.error']
+        (<<-HTML).gsub(/^ {8}/, '')
+        <!DOCTYPE html>
+        <html>
+          <head>
+            <style type="text/css" media="screen">
+              body {font-family:verdana;color:#333}
+              #content {width:700px;margin-left:20px}
+              #content h1 {width:99%;color:#1D6B8D;font-weight:bold}
+              #stacktrace {margin-top:-20px}
+              #stacktrace pre {font-size:12px;border-left:2px solid #ddd;padding-left:10px}
+              #stacktrace img {margin-top:10px}
+            </style>
+          </head>
+          <body>
+            <div id="content">
+              <img src="/sinatra_custom_images/500.png">
+              <div class="info">
+                Params: <pre>#{params.inspect}</pre>
+              </div>
+              <div id="stacktrace">
+                <h1>#{escape_html(@error.class.name + ' - ' + @error.message.to_s)}</h1>
+                <pre><code>#{escape_html(@error.backtrace.join("\n"))}</code></pre>
+              </div>
+            </div>
+          </body>
+        </html>
+        HTML
       end
     end
-  end
-  
-end
-
-def get(path, options ={}, &b)
-  Sinatra.application.define_event(:get, path, options, &b)
-end
-
-def post(path, options ={}, &b)
-  Sinatra.application.define_event(:post, path, options, &b)
-end
 
-def put(path, options ={}, &b)
-  Sinatra.application.define_event(:put, path, options, &b)
-end
+  end
 
-def delete(path, options ={}, &b)
-  Sinatra.application.define_event(:delete, path, options, &b)
 end
 
-def before(&b)
-  Sinatra.application.define_filter(:before, &b)
+# Delegate DSLish methods to the currently active Sinatra::Application
+# instance.
+Sinatra::Application::FORWARD_METHODS.each do |method|
+  eval(<<-EOS, binding, '(__DSL__)', 1)
+    def #{method}(*args, &b)
+      Sinatra.application.#{method}(*args, &b)
+    end
+  EOS
 end
 
 def helpers(&b)
   Sinatra::EventContext.class_eval(&b)
 end
 
-def error(type = Sinatra::ServerError, options = {}, &b)
-  Sinatra.application.define_error(type, options, &b)
-end
-
-def not_found(options = {}, &b)
-  Sinatra.application.define_error(Sinatra::NotFound, options, &b)
-end
-
-def layout(name = :layout, &b)
-  Sinatra.application.define_template(name, &b)
-end
-
-def template(name, &b)
-  Sinatra.application.define_template(name, &b)
-end
-
 def use_in_file_templates!
   require 'stringio'
   templates = IO.read(caller.first.split(':').first).split('__FILE__').last
   data = StringIO.new(templates)
   current_template = nil
   data.each do |line|
-    if line =~ /^##\s?(.*)/
+    if line =~ /^@@\s?(.*)/
       current_template = $1.to_sym
       Sinatra.application.templates[current_template] = ''
     elsif current_template
@@ -1006,22 +1388,6 @@ def use_in_file_templates!
   end
 end
 
-def configures(*envs, &b)
-  yield if  !Sinatra.application.reloading && 
-            (envs.include?(Sinatra.application.options.env) ||
-            envs.empty?)
-end
-alias :configure :configures
-
-def set_options(opts)
-  Sinatra::Application.default_options.merge!(opts)
-  Sinatra.application.options = nil
-end
-
-def set_option(key, value)
-  set_options(key => value)
-end
-
 def mime(ext, type)
   Rack::File::MIME_TYPES[ext.to_s] = type
 end
@@ -1029,85 +1395,33 @@ end
 ### Misc Core Extensions
 
 module Kernel
-
   def silence_warnings
     old_verbose, $VERBOSE = $VERBOSE, nil
     yield
   ensure
     $VERBOSE = old_verbose
   end
-
-end
-
-class NilClass
-
-  # Returns nil.  Necessary for mappings where
-  # params are optional, such as: '/:blah?'
-  #   nil.from_param # => nil
-  def from_param
-    nil
-  end
-
-end
-
-class String
-
-  # Converts +self+ to an escaped URI parameter value
-  #   'Foo Bar'.to_param # => 'Foo%20Bar'
-  def to_param
-    URI.escape(self)
-  end
-  
-  # Converts +self+ from an escaped URI parameter value
-  #   'Foo%20Bar'.from_param # => 'Foo Bar'
-  def from_param
-    URI.unescape(self)
-  end
-  
-end
-
-class Hash
-  
-  def to_params
-    map { |k,v| "#{k}=#{URI.escape(v)}" }.join('&')
-  end
-  
-  def symbolize_keys
-    self.inject({}) { |h,(k,v)| h[k.to_sym] = v; h }
-  end
-  
-  def pass(*keys)
-    reject { |k,v| !keys.include?(k) }
-  end
-  
 end
 
 class Symbol
-  
-  def to_proc 
+  def to_proc
     Proc.new { |*args| args.shift.__send__(self, *args) }
   end
-  
 end
 
 class Array
-  
   def to_hash
     self.inject({}) { |h, (k, v)|  h[k] = v; h }
   end
-  
   def to_proc
     Proc.new { |*args| args.shift.__send__(self[0], *(args + self[1..-1])) }
   end
-  
 end
 
 module Enumerable
-  
   def eject(&block)
     find { |e| result = block[e] and break result }
   end
-  
 end
 
 ### Core Extension results for throw :halt
@@ -1154,9 +1468,10 @@ end
 at_exit do
   raise $! if $!
   if Sinatra.application.options.run
-    Sinatra.run 
+    Sinatra.run
   end
 end
 
-mime :xml,  'application/xml'
+mime :xml, 'application/xml'
 mime :js,  'application/javascript'
+mime :png, 'image/png'