darkhelmet-sinatra 0.9.1.1 → 0.10.1

data/lib/sinatra.rb

@@ -3,6 +3,5 @@ $LOAD_PATH.unshift(libdir) unless $LOAD_PATH.include?(libdir)
 
 require 'sinatra/base'
 require 'sinatra/main'
-require 'sinatra/compat'
 
-use_in_file_templates!
+enable :inline_templates

data/lib/sinatra/base.rb

@@ -3,10 +3,17 @@ require 'time'
 require 'uri'
 require 'rack'
 require 'rack/builder'
-require 'colored'
+require 'sinatra/showexceptions'
+
+# require tilt if available; fall back on bundled version.
+begin
+  require 'tilt'
+rescue LoadError
+  require 'sinatra/tilt'
+end
 
 module Sinatra
-  VERSION = '0.9.1.1'
+  VERSION = '0.10.1'
 
   # The request object. See Rack::Request for more info:
   # http://rack.rubyforge.org/doc/classes/Rack/Request.html
@@ -15,6 +22,7 @@ module Sinatra
       @env['HTTP_USER_AGENT']
     end
 
+    # Returns an array of acceptable media types for the response
     def accept
       @env['HTTP_ACCEPT'].to_s.split(',').map { |a| a.strip }
     end
@@ -22,9 +30,13 @@ module Sinatra
     # Override Rack 0.9.x's #params implementation (see #72 in lighthouse)
     def params
       self.GET.update(self.POST)
-    rescue EOFError => boom
+    rescue EOFError, Errno::ESPIPE
       self.GET
     end
+
+    def secure?
+      (@env['HTTP_X_FORWARDED_PROTO'] || @env['rack.url_scheme']) == 'https'
+    end
   end
 
   # The response object. See Rack::Response and Rack::ResponseHelpers for
@@ -32,16 +44,6 @@ module Sinatra
   # http://rack.rubyforge.org/doc/classes/Rack/Response.html
   # http://rack.rubyforge.org/doc/classes/Rack/Response/Helpers.html
   class Response < Rack::Response
-    def initialize
-      @status, @body = 200, []
-      @header = Rack::Utils::HeaderHash.new({'Content-Type' => 'text/html'})
-    end
-
-    def write(str)
-      @body << str.to_s
-      str
-    end
-
     def finish
       @body = block if block_given?
       if [204, 304].include?(status.to_i)
@@ -52,7 +54,7 @@ module Sinatra
         body = [body] if body.respond_to? :to_str
         if body.respond_to?(:to_ary)
           header["Content-Length"] = body.to_ary.
-            inject(0) { |len, part| len + part.bytesize }.to_s
+            inject(0) { |len, part| len + Rack::Utils.bytesize(part) }.to_s
         end
         [status.to_i, header.to_hash, body]
       end
@@ -63,7 +65,7 @@ module Sinatra
     def code ; 404 ; end
   end
 
-  # Methods available to routes, before filters, and views.
+  # Methods available to routes, before/after filters, and views.
   module Helpers
     # Set or retrieve the response status code.
     def status(value=nil)
@@ -113,20 +115,20 @@ module Sinatra
     end
 
     # Look up a media type by file extension in Rack's mime registry.
-    def media_type(type)
-      Base.media_type(type)
+    def mime_type(type)
+      Base.mime_type(type)
     end
 
     # Set the Content-Type of the response body given a media type or file
     # extension.
     def content_type(type, params={})
-      media_type = self.media_type(type)
-      fail "Unknown media type: %p" % type if media_type.nil?
+      mime_type = self.mime_type(type)
+      fail "Unknown media type: %p" % type if mime_type.nil?
       if params.any?
         params = params.collect { |kv| "%s=%s" % kv }.join(', ')
-        response['Content-Type'] = [media_type, params].join(";")
+        response['Content-Type'] = [mime_type, params].join(";")
       else
-        response['Content-Type'] = media_type
+        response['Content-Type'] = mime_type
       end
     end
 
@@ -145,8 +147,8 @@ module Sinatra
       stat = File.stat(path)
       last_modified stat.mtime
 
-      content_type media_type(opts[:type]) ||
-        media_type(File.extname(path)) ||
+      content_type mime_type(opts[:type]) ||
+        mime_type(File.extname(path)) ||
         response['Content-Type'] ||
         'application/octet-stream'
 
@@ -163,6 +165,8 @@ module Sinatra
       not_found
     end
 
+    # Rack response body used to deliver static files. The file contents are
+    # generated iteratively in 8K chunks.
     class StaticFile < ::File #:nodoc:
       alias_method :to_path, :path
       def each
@@ -173,6 +177,57 @@ module Sinatra
       end
     end
 
+    # Specify response freshness policy for HTTP caches (Cache-Control header).
+    # Any number of non-value directives (:public, :private, :no_cache,
+    # :no_store, :must_revalidate, :proxy_revalidate) may be passed along with
+    # a Hash of value directives (:max_age, :min_stale, :s_max_age).
+    #
+    #   cache_control :public, :must_revalidate, :max_age => 60
+    #   => Cache-Control: public, must-revalidate, max-age=60
+    #
+    # See RFC 2616 / 14.9 for more on standard cache control directives:
+    # http://tools.ietf.org/html/rfc2616#section-14.9.1
+    def cache_control(*values)
+      if values.last.kind_of?(Hash)
+        hash = values.pop
+        hash.reject! { |k,v| v == false }
+        hash.reject! { |k,v| values << k if v == true }
+      else
+        hash = {}
+      end
+
+      values = values.map { |value| value.to_s.tr('_','-') }
+      hash.each { |k,v| values << [k.to_s.tr('_', '-'), v].join('=') }
+
+      response['Cache-Control'] = values.join(', ') if values.any?
+    end
+
+    # Set the Expires header and Cache-Control/max-age directive. Amount
+    # can be an integer number of seconds in the future or a Time object
+    # indicating when the response should be considered "stale". The remaining
+    # "values" arguments are passed to the #cache_control helper:
+    #
+    #   expires 500, :public, :must_revalidate
+    #   => Cache-Control: public, must-revalidate, max-age=60
+    #   => Expires: Mon, 08 Jun 2009 08:50:17 GMT
+    #
+    def expires(amount, *values)
+      values << {} unless values.last.kind_of?(Hash)
+
+      if amount.respond_to?(:to_time)
+        max_age = amount.to_time - Time.now
+        time = amount.to_time
+      else
+        max_age = amount
+        time = Time.now + amount
+      end
+
+      values.last.merge!(:max_age => max_age)
+      cache_control(*values)
+
+      response['Expires'] = time.httpdate
+    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+.
@@ -190,7 +245,7 @@ module Sinatra
 
     # 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
+    # identifies the current version of the resource. The +kind+ argument
     # indicates whether the etag should be used as a :strong (default) or :weak
     # cache validator.
     #
@@ -215,110 +270,90 @@ module Sinatra
 
   end
 
-  # Template rendering methods. Each method takes a the name of a template
-  # to render as a Symbol and returns a String with the rendered output.
+  # Template rendering methods. Each method takes the name of a template
+  # to render as a Symbol and returns a String with the rendered output,
+  # as well as an optional hash with additional options.
+  #
+  # `template` is either the name or path of the template as symbol
+  # (Use `:'subdir/myview'` for views in subdirectories), or a string
+  # that will be rendered.
+  #
+  # Possible options are:
+  #   :layout       If set to false, no layout is rendered, otherwise
+  #                 the specified layout is used (Ignored for `sass`)
+  #   :locals       A hash with local variables that should be available
+  #                 in the template
   module Templates
-    def erb(template, options={})
-      require 'erb' unless defined? ::ERB
-      render :erb, template, options
+    def erb(template, options={}, locals={})
+      render :erb, template, options, locals
+    end
+
+    def erubis(template, options={}, locals={})
+      render :erubis, template, options, locals
     end
 
-    def haml(template, options={})
-      require 'haml' unless defined? ::Haml
-      options[:options] ||= self.class.haml if self.class.respond_to? :haml
-      render :haml, template, options
+    def haml(template, options={}, locals={})
+      render :haml, template, options, locals
     end
 
-    def sass(template, options={}, &block)
-      require 'sass' unless defined? ::Sass
+    def sass(template, options={}, locals={})
       options[:layout] = false
-      render :sass, template, options
+      render :sass, template, options, locals
     end
 
-    def builder(template=nil, options={}, &block)
-      require 'builder' unless defined? ::Builder
+    def builder(template=nil, options={}, locals={}, &block)
       options, template = template, nil if template.is_a?(Hash)
-      template = lambda { block } if template.nil?
-      render :builder, template, options
+      template = Proc.new { block } if template.nil?
+      render :builder, template, options, locals
     end
 
   private
-    def render(engine, template, options={}) #:nodoc:
-      data   = lookup_template(engine, template, options)
-      output = __send__("render_#{engine}", template, data, options)
-      layout, data = lookup_layout(engine, options)
-      if layout
-        __send__("render_#{engine}", layout, data, options) { output }
-      else
-        output
-      end
-    end
-
-    def lookup_template(engine, template, options={})
-      case template
-      when Symbol
-        if cached = self.class.templates[template]
-          lookup_template(engine, cached, options)
-        else
-          ::File.read(template_path(engine, template, options))
-        end
-      when Proc
-        template.call
-      when String
-        template
-      else
-        raise ArgumentError
-      end
-    end
-
-    def lookup_layout(engine, options)
-      return if options[:layout] == false
-      options.delete(:layout) if options[:layout] == true
-      template = options[:layout] || :layout
-      data     = lookup_template(engine, template, options)
-      [template, data]
-    rescue Errno::ENOENT
-      nil
-    end
-
-    def template_path(engine, template, options={})
-      views_dir =
-        options[:views_directory] || self.options.views || "./views"
-      "#{views_dir}/#{template}.#{engine}"
-    end
-
-    def render_erb(template, data, options, &block)
-      original_out_buf = @_out_buf
-      data = data.call if data.kind_of? Proc
+    def render(engine, data, options={}, locals={}, &block)
+      # merge app-level options
+      options = settings.send(engine).merge(options) if settings.respond_to?(engine)
 
-      instance = ::ERB.new(data, nil, nil, '@_out_buf')
-      locals = options[:locals] || {}
-      locals_assigns = locals.to_a.collect { |k,v| "#{k} = locals[:#{k}]" }
+      # extract generic options
+      locals = options.delete(:locals) || locals || {}
+      views = options.delete(:views) || settings.views || "./views"
+      layout = options.delete(:layout)
+      layout = :layout if layout.nil? || layout == true
 
-      src = "#{locals_assigns.join("\n")}\n#{instance.src}"
-      eval src, binding, '(__ERB__)', locals_assigns.length + 1
-      @_out_buf, result = original_out_buf, @_out_buf
-      result
-    end
+      # compile and render template
+      template = compile_template(engine, data, options, views)
+      output = template.render(self, locals, &block)
 
-    def render_haml(template, data, options, &block)
-      engine = ::Haml::Engine.new(data, options[:options] || {})
-      engine.render(self, options[:locals] || {}, &block)
-    end
+      # render layout
+      if layout
+        begin
+          options = options.merge(:views => views, :layout => false)
+          output = render(engine, layout, options, locals) { output }
+        rescue Errno::ENOENT
+        end
+      end
 
-    def render_sass(template, data, options, &block)
-      engine = ::Sass::Engine.new(data, options[:sass] || {})
-      engine.render
+      output
     end
 
-    def render_builder(template, data, options, &block)
-      xml = ::Builder::XmlMarkup.new(:indent => 2)
-      if data.respond_to?(:to_str)
-        eval data.to_str, binding, '<BUILDER>', 1
-      elsif data.kind_of?(Proc)
-        data.call(xml)
+    def compile_template(engine, data, options, views)
+      @template_cache.fetch engine, data, options do
+        case
+        when data.is_a?(Symbol)
+          body, path, line = self.class.templates[data]
+          if body
+            body = body.call if body.respond_to?(:call)
+            Tilt[engine].new(path, line.to_i, options) { body }
+          else
+            path = ::File.join(views, "#{data}.#{engine}")
+            Tilt[engine].new(path, 1, options)
+          end
+        when data.is_a?(Proc) || data.is_a?(String)
+          body = data.is_a?(String) ? Proc.new { data } : data
+          path, line = self.class.caller_locations.first
+          Tilt[engine].new(path, line.to_i, options, &body)
+        else
+          raise ArgumentError
+        end
       end
-      xml.target!
     end
   end
 
@@ -332,6 +367,7 @@ module Sinatra
 
     def initialize(app=nil)
       @app = app
+      @template_cache = Tilt::Cache.new
       yield self if block_given?
     end
 
@@ -346,7 +382,7 @@ module Sinatra
       @env      = env
       @request  = Request.new(env)
       @response = Response.new
-      @params   = nil
+      @params   = indifferent_params(@request.params)
 
       invoke { dispatch! }
       invoke { error_block!(response.status) }
@@ -364,20 +400,24 @@ module Sinatra
       [status, header, body]
     end
 
-    # Access options defined with Base.set.
-    def options
+    # Access settings defined with Base.set.
+    def settings
       self.class
     end
+    alias_method :options, :settings
 
-    # Exit the current block and halt the response.
+    # Exit the current block, halts any further processing
+    # of the request, and returns the specified response.
     def halt(*response)
       response = response.first if response.length == 1
       throw :halt, response
     end
 
     # Pass control to the next matching route.
-    def pass
-      throw :pass
+    # If there are no more matching routes, Sinatra will
+    # return a 404 response.
+    def pass(&block)
+      throw :pass, block
     end
 
     # Forward the request to the downstream app -- middleware only.
@@ -391,21 +431,26 @@ module Sinatra
     end
 
   private
-    # Run before filters and then locate and run a matching route.
-    def route!
-      @params = nested_params(@request.params)
+    # Run before filters defined on the class and all superclasses.
+    def before_filter!(base=self.class)
+      before_filter!(base.superclass) if base.superclass.respond_to?(:before_filters)
+      base.before_filters.each { |block| instance_eval(&block) }
+    end
 
-      # before filters
-      self.class.filters.each { |block| instance_eval(&block) }
+    # Run after filters defined on the class and all superclasses.
+    def after_filter!(base=self.class)
+      after_filter!(base.superclass) if base.superclass.respond_to?(:after_filters)
+      base.after_filters.each { |block| instance_eval(&block) }
+    end
 
-      # routes
-      if routes = self.class.routes[@request.request_method]
+    # Run routes defined on the class and all superclasses.
+    def route!(base=self.class, pass_block=nil)
+      if routes = base.routes[@request.request_method]
         original_params = @params
         path            = unescape(@request.path_info)
 
-        routes.each do |pattern, rpath, keys, conditions, block|
+        routes.each do |pattern, keys, conditions, block|
           if match = pattern.match(path)
-            @env['rack.errors'].write("=== Path '#{path}' matched route '#{rpath}'\n".green)
             values = match.captures.to_a
             params =
               if keys.any?
@@ -425,19 +470,39 @@ module Sinatra
             @params = original_params.merge(params)
             @block_params = values
 
-            catch(:pass) do
+            pass_block = catch(:pass) do
               conditions.each { |cond|
                 throw :pass if instance_eval(&cond) == false }
-              throw :halt, instance_eval(&block)
+              route_eval(&block)
             end
-          else
-            @env['rack.errors'].write("=== Path '#{path}' failed route '#{rpath}'\n".red)
           end
         end
+
+        @params = original_params
       end
 
-      # No matching route found or all routes passed -- forward downstream
-      # when running as middleware; 404 when running as normal app.
+      # Run routes defined in superclass.
+      if base.superclass.respond_to?(:routes)
+        route! base.superclass, pass_block
+        return
+      end
+
+      route_eval(&pass_block) if pass_block
+
+      route_missing
+    end
+
+    # Run a route block and throw :halt with the result.
+    def route_eval(&block)
+      throw :halt, instance_eval(&block)
+    end
+
+    # No matching route was found or all routes passed. The default
+    # implementation is to forward the request downstream when running
+    # as middleware (@app is non-nil); when no downstream app is set, raise
+    # a NotFound exception. Subclasses can override this method to perform
+    # custom route miss logic.
+    def route_missing
       if @app
         forward
       else
@@ -445,17 +510,25 @@ module Sinatra
       end
     end
 
-    def nested_params(params)
-      return indifferent_hash.merge(params) if !params.keys.join.include?('[')
-      params.inject indifferent_hash do |res, (key,val)|
-        if key.include?('[')
-          head = key.split(/[\]\[]+/)
-          last = head.pop
-          head.inject(res){ |hash,k| hash[k] ||= indifferent_hash }[last] = val
-        else
-          res[key] = val
-        end
-        res
+    # Attempt to serve static files from public directory. Throws :halt when
+    # a matching file is found, returns nil otherwise.
+    def static!
+      return if (public_dir = settings.public).nil?
+      public_dir = File.expand_path(public_dir)
+
+      path = File.expand_path(public_dir + unescape(request.path_info))
+      return if path[0, public_dir.length] != public_dir
+      return unless File.file?(path)
+
+      send_file path, :disposition => nil
+    end
+
+    # Enable string or symbol key access to the nested params hash.
+    def indifferent_params(params)
+      params = indifferent_hash.merge(params)
+      params.each do |key, value|
+        next unless value.is_a?(Hash)
+        params[key] = indifferent_params(value)
       end
     end
 
@@ -498,25 +571,30 @@ module Sinatra
 
     # Dispatch a request with error handling.
     def dispatch!
+      static! if settings.static? && (request.get? || request.head?)
+      before_filter!
       route!
     rescue NotFound => boom
       handle_not_found!(boom)
     rescue ::Exception => boom
       handle_exception!(boom)
+    ensure
+      after_filter!
     end
 
     def handle_not_found!(boom)
-      @env['sinatra.error'] = boom
-      @response.status      = 404
-      @response.body        = ['<h1>Not Found</h1>']
+      @env['sinatra.error']          = boom
+      @response.status               = 404
+      @response.headers['X-Cascade'] = 'pass'
+      @response.body                 = ['<h1>Not Found</h1>']
       error_block! boom.class, NotFound
     end
 
     def handle_exception!(boom)
       @env['sinatra.error'] = boom
 
-      dump_errors!(boom) if options.dump_errors?
-      raise boom         if options.raise_errors?
+      dump_errors!(boom) if settings.dump_errors?
+      raise boom         if settings.raise_errors? || settings.show_exceptions?
 
       @response.status = 500
       error_block! boom.class, Exception
@@ -524,11 +602,16 @@ module Sinatra
 
     # Find an custom error block for the key(s) specified.
     def error_block!(*keys)
-      errmap = self.class.errors
       keys.each do |key|
-        if block = errmap[key]
-          res = instance_eval(&block)
-          return res
+        base = self.class
+        while base.respond_to?(:errors)
+          if block = base.errors[key]
+            # found a handler, eval and return result
+            res = instance_eval(&block)
+            return res
+          else
+            base = base.superclass
+          end
         end
       end
       nil
@@ -538,11 +621,11 @@ module Sinatra
       backtrace = clean_backtrace(boom.backtrace)
       msg = ["#{boom.class} - #{boom.message}:",
         *backtrace].join("\n ")
-      @env['rack.errors'].write(msg)
+      @env['rack.errors'].puts(msg)
     end
 
     def clean_backtrace(trace)
-      return trace unless options.clean_trace?
+      return trace unless settings.clean_trace?
 
       trace.reject { |line|
         line =~ /lib\/sinatra.*\.rb/ ||
@@ -550,20 +633,46 @@ module Sinatra
       }.map! { |line| line.gsub(/^\.\//, '') }
     end
 
-    @routes     = {}
-    @filters    = []
-    @conditions = []
-    @templates  = {}
-    @middleware = []
-    @errors     = {}
-    @prototype  = nil
-    @extensions = []
-
     class << self
-      attr_accessor :routes, :filters, :conditions, :templates,
-        :middleware, :errors
+      attr_reader :routes, :before_filters, :after_filters, :templates, :errors
+
+      def reset!
+        @conditions     = []
+        @routes         = {}
+        @before_filters = []
+        @after_filters  = []
+        @errors         = {}
+        @middleware     = []
+        @prototype      = nil
+        @extensions     = []
+
+        if superclass.respond_to?(:templates)
+          @templates = Hash.new { |hash,key| superclass.templates[key] }
+        else
+          @templates = {}
+        end
+      end
 
-    public
+      # Extension modules registered on this class and all superclasses.
+      def extensions
+        if superclass.respond_to?(:extensions)
+          (@extensions + superclass.extensions).uniq
+        else
+          @extensions
+        end
+      end
+
+      # Middleware used in this class and all superclasses.
+      def middleware
+        if superclass.respond_to?(:middleware)
+          superclass.middleware + @middleware
+        else
+          @middleware
+        end
+      end
+
+      # Sets an option to the given value.  If the value is a proc,
+      # the proc will be called every time the option is accessed.
       def set(option, value=self)
         if value.kind_of?(Proc)
           metadef(option, &value)
@@ -579,45 +688,59 @@ module Sinatra
         self
       end
 
+      # Same as calling `set :option, true` for each of the given options.
       def enable(*opts)
         opts.each { |key| set(key, true) }
       end
 
+      # Same as calling `set :option, false` for each of the given options.
       def disable(*opts)
         opts.each { |key| set(key, false) }
       end
 
+      # Define a custom error handler. Optionally takes either an Exception
+      # class, or an HTTP status code to specify which errors should be
+      # handled.
       def error(codes=Exception, &block)
-        if codes.respond_to? :each
-          codes.each { |err| error(err, &block) }
-        else
-          @errors[codes] = block
-        end
+        Array(codes).each { |code| @errors[code] = block }
       end
 
+      # Sugar for `error(404) { ... }`
       def not_found(&block)
         error 404, &block
       end
 
+      # Define a named template. The block must return the template source.
       def template(name, &block)
-        templates[name] = block
+        filename, line = caller_locations.first
+        templates[name] = [block, filename, line.to_i]
       end
 
+      # Define the layout template. The block must return the template source.
       def layout(name=:layout, &block)
         template name, &block
       end
 
-      def use_in_file_templates!
-        ignore = [/lib\/sinatra.*\.rb/, /\(.*\)/, /rubygems\/custom_require\.rb/]
-        file = caller.
-          map  { |line| line.sub(/:\d+.*$/, '') }.
-          find { |line| ignore.all? { |pattern| line !~ pattern } }
-        if data = ::IO.read(file).split('__END__')[1]
-          data.gsub!(/\r\n/, "\n")
+      # Load embeded templates from the file; uses the caller's __FILE__
+      # when no file is specified.
+      def inline_templates=(file=nil)
+        file = (file.nil? || file == true) ? caller_files.first : file
+
+        begin
+          app, data =
+            ::IO.read(file).gsub("\r\n", "\n").split(/^__END__$/, 2)
+        rescue Errno::ENOENT
+          app, data = nil
+        end
+
+        if data
+          lines = app.count("\n") + 1
           template = nil
           data.each_line do |line|
+            lines += 1
             if line =~ /^@@\s*(.*)/
-              template = templates[$1.to_sym] = ''
+              template = ''
+              templates[$1.to_sym] = [template, file, lines]
             elsif template
               template << line
             end
@@ -625,17 +748,30 @@ module Sinatra
         end
       end
 
-      # Look up a media type by file extension in Rack's mime registry.
-      def media_type(type)
+      # Lookup or register a mime type in Rack's mime registry.
+      def mime_type(type, value=nil)
         return type if type.nil? || type.to_s.include?('/')
         type = ".#{type}" unless type.to_s[0] == ?.
-        Rack::Mime.mime_type(type, nil)
+        return Rack::Mime.mime_type(type, nil) unless value
+        Rack::Mime::MIME_TYPES[type] = value
       end
 
+      # Define a before filter; runs before all requests within the same
+      # context as route handlers and may access/modify the request and
+      # response.
       def before(&block)
-        @filters << block
+        @before_filters << block
+      end
+
+      # Define an after filter; runs after all requests within the same
+      # context as route handlers and may access/modify the request and
+      # response.
+      def after(&block)
+        @after_filters << block
       end
 
+      # Add a route condition. The route is considered non-matching when the
+      # block returns false.
       def condition(&block)
         @conditions << block
       end
@@ -655,10 +791,11 @@ module Sinatra
           end
         }
       end
+      alias_method :agent, :user_agent
 
-      def accept_mime_types(types)
+      def provides(*types)
         types = [types] unless types.kind_of? Array
-        types.map!{|t| media_type(t)}
+        types.map!{|t| mime_type(t)}
 
         condition {
           matching_types = (request.accept & types)
@@ -672,6 +809,8 @@ module Sinatra
       end
 
     public
+      # Defining a `GET` handler also automatically defines
+      # a `HEAD` handler.
       def get(path, opts={}, &block)
         conditions = @conditions.dup
         route('GET', path, opts, &block)
@@ -680,16 +819,17 @@ module Sinatra
         route('HEAD', path, opts, &block)
       end
 
-      def put(path, opts={}, &bk); route 'PUT', path, opts, &bk; end
-      def post(path, opts={}, &bk); route 'POST', path, opts, &bk; end
-      def delete(path, opts={}, &bk); route 'DELETE', path, opts, &bk; end
-      def head(path, opts={}, &bk); route 'HEAD', path, opts, &bk; end
+      def put(path, opts={}, &bk);    route 'PUT',    path, opts, &bk end
+      def post(path, opts={}, &bk);   route 'POST',   path, opts, &bk end
+      def delete(path, opts={}, &bk); route 'DELETE', path, opts, &bk end
+      def head(path, opts={}, &bk);   route 'HEAD',   path, opts, &bk end
 
     private
-      def route(verb, path, opts={}, &block)
-        host_name  opts[:host]  if opts.key?(:host)
-        user_agent opts[:agent] if opts.key?(:agent)
-        accept_mime_types opts[:provides] if opts.key?(:provides)
+      def route(verb, path, options={}, &block)
+        # Because of self.options.host
+        host_name(options.delete(:host)) if options.key?(:host)
+
+        options.each {|option, args| send(option, *args)}
 
         pattern, keys = compile(path)
         conditions, @conditions = @conditions, []
@@ -703,10 +843,10 @@ module Sinatra
             lambda { unbound_method.bind(self).call }
           end
 
-        invoke_hook(:route_added, verb, path)
+        invoke_hook(:route_added, verb, path, block)
 
-        (routes[verb] ||= []).
-          push([pattern, path, keys, conditions, block]).last
+        (@routes[verb] ||= []).
+          push([pattern, keys, conditions, block]).last
       end
 
       def invoke_hook(name, *args)
@@ -718,7 +858,7 @@ module Sinatra
         if path.respond_to? :to_str
           special_chars = %w{. + ( )}
           pattern =
-            path.gsub(/((:\w+)|[\*#{special_chars.join}])/) do |match|
+            path.to_str.gsub(/((:\w+)|[\*#{special_chars.join}])/) do |match|
               case match
               when "*"
                 keys << 'splat'
@@ -731,6 +871,8 @@ module Sinatra
               end
             end
           [/^#{pattern}$/, keys]
+        elsif path.respond_to?(:keys) && path.respond_to?(:match)
+          [path, path.keys]
         elsif path.respond_to? :match
           [path, keys]
         else
@@ -739,13 +881,11 @@ module Sinatra
       end
 
     public
+      # Makes the methods defined in the block and in the Modules given
+      # in `extensions` available to the handlers and templates
       def helpers(*extensions, &block)
         class_eval(&block)  if block_given?
-        include *extensions if extensions.any?
-      end
-
-      def extensions
-        (@extensions + (superclass.extensions rescue [])).uniq
+        include(*extensions) if extensions.any?
       end
 
       def register(*extensions, &block)
@@ -757,20 +897,24 @@ module Sinatra
         end
       end
 
-      def development? ; environment == :development ; end
-      def test? ; environment == :test ; end
-      def production? ; environment == :production ; end
+      def development?; environment == :development end
+      def production?;  environment == :production  end
+      def test?;        environment == :test        end
 
+      # Set configuration options for Sinatra and/or the app.
+      # Allows scoping of settings for certain environments.
       def configure(*envs, &block)
-        return if reloading?
-        yield if envs.empty? || envs.include?(environment.to_sym)
+        yield self if envs.empty? || envs.include?(environment.to_sym)
       end
 
+      # Use the specified Rack middleware
       def use(middleware, *args, &block)
         @prototype = nil
         @middleware << [middleware, args, block]
       end
 
+      # Run the Sinatra app as a self-hosted server using
+      # Thin, Mongrel or WEBrick (in that order)
       def run!(options={})
         set options
         handler      = detect_rack_handler
@@ -783,6 +927,7 @@ module Sinatra
             server.respond_to?(:stop!) ? server.stop! : server.stop
             puts "\n== Sinatra has ended his set (crowd applauds)" unless handler_name =~/cgi/i
           end
+          set :running, true
         end
       rescue Errno::EADDRINUSE => e
         puts "== Someone is already performing on port #{port}!"
@@ -798,50 +943,18 @@ module Sinatra
       # an instance of the class new was called on.
       def new(*args, &bk)
         builder = Rack::Builder.new
-        builder.use Rack::Session::Cookie if sessions? && !test?
-        builder.use Rack::CommonLogger if logging?
-        builder.use Rack::MethodOverride if methodoverride?
-        @middleware.each { |c, args, bk| builder.use(c, *args, &bk) }
+        builder.use Rack::Session::Cookie if sessions?
+        builder.use Rack::CommonLogger    if logging?
+        builder.use Rack::MethodOverride  if methodoverride?
+        builder.use ShowExceptions        if show_exceptions?
+        middleware.each { |c,a,b| builder.use(c, *a, &b) }
+
         builder.run super
         builder.to_app
       end
 
       def call(env)
-        synchronize do
-          reload! if reload?
-          prototype.call(env)
-        end
-      end
-
-      def reloading?
-        @reloading
-      end
-
-      def reload!
-        @reloading = true
-        reset!
-        $LOADED_FEATURES.delete("sinatra.rb")
-        ::Kernel.load app_file
-        @reloading = false
-      end
-
-      def reset!(base=superclass)
-        @routes     = base.dupe_routes
-        @templates  = base.templates.dup
-        @conditions = []
-        @filters    = base.filters.dup
-        @errors     = base.errors.dup
-        @middleware = base.middleware.dup
-        @prototype  = nil
-        @extensions = []
-      end
-
-    protected
-      def dupe_routes
-        routes.inject({}) do |hash,(request_method,routes)|
-          hash[request_method] = routes.dup
-          hash
-        end
+        synchronize { prototype.call(env) }
       end
 
     private
@@ -849,7 +962,7 @@ module Sinatra
         servers = Array(self.server)
         servers.each do |server_name|
           begin
-            return Rack::Handler.get(server_name)
+            return Rack::Handler.get(server_name.downcase)
           rescue LoadError
           rescue NameError
           end
@@ -858,7 +971,7 @@ module Sinatra
       end
 
       def inherited(subclass)
-        subclass.reset! self
+        subclass.reset!
         super
       end
 
@@ -875,18 +988,47 @@ module Sinatra
         (class << self; self; end).
           send :define_method, message, &block
       end
+
+    public
+      CALLERS_TO_IGNORE = [
+        /\/sinatra(\/(base|main|showexceptions))?\.rb$/, # all sinatra code
+        /lib\/tilt.*\.rb$/,    # all tilt code
+        /\(.*\)/,              # generated code
+        /custom_require\.rb$/, # rubygems require hacks
+        /active_support/,      # active_support require hacks
+      ]
+
+      # add rubinius (and hopefully other VM impls) ignore patterns ...
+      CALLERS_TO_IGNORE.concat(RUBY_IGNORE_CALLERS) if defined?(RUBY_IGNORE_CALLERS)
+
+      # Like Kernel#caller but excluding certain magic entries and without
+      # line / method information; the resulting array contains filenames only.
+      def caller_files
+        caller_locations.
+          map { |file,line| file }
+      end
+
+      def caller_locations
+        caller(1).
+          map    { |line| line.split(/:(?=\d|in )/)[0,2] }.
+          reject { |file,line| CALLERS_TO_IGNORE.any? { |pattern| file =~ pattern } }
+      end
     end
 
+    reset!
+
     set :raise_errors, true
     set :dump_errors, false
     set :clean_trace, true
+    set :show_exceptions, false
     set :sessions, false
     set :logging, false
     set :methodoverride, false
     set :static, false
     set :environment, (ENV['RACK_ENV'] || :development).to_sym
 
-    set :run, false
+    set :run, false                       # start server via at-exit hook?
+    set :running, false                   # is the built-in server running now?
     set :server, %w[thin mongrel webrick]
     set :host, '0.0.0.0'
     set :port, 4567
@@ -895,18 +1037,7 @@ module Sinatra
     set :root, Proc.new { app_file && File.expand_path(File.dirname(app_file)) }
     set :views, Proc.new { root && File.join(root, 'views') }
     set :public, Proc.new { root && File.join(root, 'public') }
-    set :reload, Proc.new { app_file? && app_file !~ /\.ru$/i && development? }
-    set :lock, Proc.new { reload? }
-
-    # static files route
-    get(/.*[^\/]$/) do
-      pass unless options.static? && options.public?
-      public_dir = File.expand_path(options.public)
-      path = File.expand_path(public_dir + unescape(request.path_info))
-      pass if path[0, public_dir.length] != public_dir
-      pass unless File.file?(path)
-      send_file path, :disposition => nil
-    end
+    set :lock, false
 
     error ::Exception do
       response.status = 500
@@ -922,6 +1053,8 @@ module Sinatra
       end
 
       error NotFound do
+        content_type 'text/html'
+
         (<<-HTML).gsub(/^ {8}/, '')
         <!DOCTYPE html>
         <html>
@@ -943,41 +1076,13 @@ module Sinatra
         </html>
         HTML
       end
-
-      error do
-        next unless err = request.env['sinatra.error']
-        heading = err.class.name + ' - ' + err.message.to_s
-        (<<-HTML).gsub(/^ {8}/, '')
-        <!DOCTYPE html>
-        <html>
-        <head>
-          <style type="text/css">
-            body {font-family:verdana;color:#333}
-            #c {margin-left:20px}
-            h1 {color:#1D6B8D;margin:0;margin-top:-30px}
-            h2 {color:#1D6B8D;font-size:18px}
-            pre {border-left:2px solid #ddd;padding-left:10px;color:#000}
-            img {margin-top:10px}
-          </style>
-        </head>
-        <body>
-          <div id="c">
-            <img src="/__sinatra__/500.png">
-            <h1>#{escape_html(heading)}</h1>
-            <pre>#{escape_html(clean_backtrace(err.backtrace) * "\n")}</pre>
-            <h2>Params</h2>
-            <pre>#{escape_html(params.inspect)}</pre>
-          </div>
-        </body>
-        </html>
-        HTML
-      end
     end
   end
 
   # Base class for classic style (top-level) applications.
   class Default < Base
     set :raise_errors, Proc.new { test? }
+    set :show_exceptions, Proc.new { development? }
     set :dump_errors, true
     set :sessions, false
     set :logging, Proc.new { ! test? }
@@ -987,7 +1092,7 @@ module Sinatra
 
     def self.register(*extensions, &block) #:nodoc:
       added_methods = extensions.map {|m| m.public_instance_methods }.flatten
-      Delegator.delegate *added_methods
+      Delegator.delegate(*added_methods)
       super(*extensions, &block)
     end
   end
@@ -997,24 +1102,29 @@ module Sinatra
   class Application < Default
   end
 
+  # Sinatra delegation mixin. Mixing this module into an object causes all
+  # methods to be delegated to the Sinatra::Application class. Used primarily
+  # at the top-level.
   module Delegator #:nodoc:
     def self.delegate(*methods)
       methods.each do |method_name|
         eval <<-RUBY, binding, '(__DELEGATE__)', 1
           def #{method_name}(*args, &b)
-            ::Sinatra::Application.#{method_name}(*args, &b)
+            ::Sinatra::Application.send(#{method_name.inspect}, *args, &b)
           end
-          private :#{method_name}
+          private #{method_name.inspect}
         RUBY
       end
     end
 
-    delegate :get, :put, :post, :delete, :head, :template, :layout, :before,
-             :error, :not_found, :configures, :configure, :set, :set_option,
-             :set_options, :enable, :disable, :use, :development?, :test?,
+    delegate :get, :put, :post, :delete, :head, :template, :layout,
+             :before, :after, :error, :not_found, :configure, :set, :mime_type,
+             :enable, :disable, :use, :development?, :test?,
              :production?, :use_in_file_templates!, :helpers
   end
 
+  # Create a new Sinatra application. The block is evaluated in the new app's
+  # class scope.
   def self.new(base=Base, options={}, &block)
     base = Class.new(base)
     base.send :class_eval, &block if block_given?
@@ -1031,13 +1141,3 @@ module Sinatra
     Default.helpers(*extensions, &block)
   end
 end
-
-class String #:nodoc:
-  # Define String#each under 1.9 for Rack compatibility. This should be
-  # removed once Rack is fully 1.9 compatible.
-  alias_method :each, :each_line  unless ''.respond_to? :each
-
-  # Define String#bytesize as an alias to String#length for Ruby 1.8.6 and
-  # earlier.
-  alias_method :bytesize, :length unless ''.respond_to? :bytesize
-end