sinatra 0.9.6 → 1.0.a

data/README.rdoc

@@ -1,6 +1,6 @@
 = Sinatra
 
-Sinatra is a DSL for quickly creating web-applications in Ruby with minimal
+Sinatra is a DSL for quickly creating web applications in Ruby with minimal
 effort:
 
   # myapp.rb
@@ -150,6 +150,19 @@ and overridden on an individual basis.
 
 Renders <tt>./views/index.erb</tt>
 
+=== Erubis
+
+The erubis gem/library is required to render builder templates:
+
+  ## You'll need to require erubis in your app
+  require 'erubis'
+
+  get '/' do
+    erubis :index
+  end
+
+Renders <tt>./views/index.erubis</tt>
+
 === Builder Templates
 
 The builder gem/library is required to render builder templates:
@@ -296,9 +309,17 @@ filters are accessible by routes and templates:
     params[:splat] #=> 'bar/baz'
   end
 
+After filter are evaluated after each request within the context of the
+request and can also modify the request and response. Instance variables
+set in before filters and routes are accessible by after filters:
+
+  after do
+    puts response.status
+  end
+
 == Halting
 
-To immediately stop a request during a before filter or route use:
+To immediately stop a request within a filter or route use:
 
   halt
 
@@ -374,7 +395,7 @@ code is 404, the <tt>not_found</tt> handler is invoked:
 === Error
 
 The +error+ handler is invoked any time an exception is raised from a route
-block or before filter. The exception object can be obtained from the
+block or a filter. The exception object can be obtained from the
 <tt>sinatra.error</tt> Rack variable:
 
   error do
@@ -544,19 +565,20 @@ system. The +Sinatra::Application+ class -- a special subclass of
 Sinatra::Base -- receives all :get, :put, :post, :delete, :before,
 :error, :not_found, :configure, and :set messages sent to the
 top-level. Have a look at the code for yourself: here's the
-{Sinatra::Delegator mixin}[http://github.com/sinatra/sinatra/blob/0.9.5/lib/sinatra/base.rb#L1124-1143]
-being {included into the main namespace}[http://github.com/sinatra/sinatra/blob/0.9.5/lib/sinatra/main.rb#L25].
+{Sinatra::Delegator mixin}[http://github.com/sinatra/sinatra/blob/master/lib/sinatra/base.rb#L1064]
+being {included into the main namespace}[http://github.com/sinatra/sinatra/blob/master/lib/sinatra/main.rb#L25].
 
 == Command line
 
 Sinatra applications can be run directly:
 
-  ruby myapp.rb [-h] [-x] [-e ENVIRONMENT] [-p PORT] [-s HANDLER]
+  ruby myapp.rb [-h] [-x] [-e ENVIRONMENT] [-p PORT] [-h HOST] [-s HANDLER]
 
 Options are:
 
   -h # help
   -p # set the port (default is 4567)
+  -h # set the host (default is 0.0.0.0)
   -e # set the environment (default is development)
   -s # specify rack server/handler (default is thin)
   -x # turn on the mutex lock (default is off)
@@ -589,12 +611,12 @@ To update the Sinatra sources in the future:
 
 == More
 
-* {Project Website}[http://www.sinatrarb.com/] - Additional documentation,
+* {Project Website}[http://sinatra.github.com/] - Additional documentation,
   news, and links to other resources.
-* {Contributing}[http://www.sinatrarb.com/contributing] - Find a bug? Need
+* {Contributing}[http://sinatra.github.com/contributing.html] - Find a bug? Need
   help? Have a patch?
 * {Lighthouse}[http://sinatra.lighthouseapp.com] - Issue tracking and release
   planning.
 * {Twitter}[http://twitter.com/sinatra]
-* {Mailing List}[http://groups.google.com/group/sinatrarb/topics]
+* {Mailing List}[http://groups.google.com/group/sinatrarb]
 * {IRC: #sinatra}[irc://chat.freenode.net/#sinatra] on http://freenode.net

data/Rakefile

@@ -2,88 +2,38 @@ require 'rake/clean'
 require 'rake/testtask'
 require 'fileutils'
 
-task :default => [:test, :compat]
+task :default => :test
 task :spec => :test
 
-# SPECS ===============================================================
+def source_version
+  line = File.read('lib/sinatra/base.rb')[/^\s*VERSION = .*/]
+  line.match(/.*VERSION = '(.*)'/)[1]
+end
 
-task(:test) { puts "==> Running main test suite" }
+# SPECS ===============================================================
 
 Rake::TestTask.new(:test) do |t|
   t.test_files = FileList['test/*_test.rb']
-  t.ruby_opts = ['-rubygems'] if defined? Gem
+  t.ruby_opts = ['-rubygems -I.'] if defined? Gem
 end
 
-desc "Run < 0.9.x compatibility specs"
-task :compat do
-  begin
-    require 'mocha'
-    require 'test/spec'
-    at_exit { exit 0 } # disable test-spec at_exit runner
-
-    puts "==> Running compat test suite"
-    Rake::TestTask.new(:compat) do |t|
-      t.test_files = FileList['compat/*_test.rb']
-      t.ruby_opts = ['-rubygems'] if defined? Gem
-    end
-  rescue LoadError
-    warn 'Skipping compat tests. mocha and/or test-spec gems not installed.'
+# Rcov ================================================================
+namespace :test do
+  desc 'Mesures test coverage'
+  task :coverage do
+    rm_f "coverage"
+    rcov = "rcov --text-summary --test-unit-only -Ilib"
+    system("#{rcov} --no-html --no-color test/*_test.rb")
   end
 end
 
-# PACKAGING ============================================================
-
-# Load the gemspec using the same limitations as github
-def spec
-  @spec ||= eval(File.read('sinatra.gemspec'))
-end
-
-def package(ext='')
-  "pkg/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 'pkg/'
-CLOBBER.include('pkg')
-
-file package('.gem') => %w[pkg/ sinatra.gemspec] + spec.files do |f|
-  sh "gem build sinatra.gemspec"
-  mv File.basename(f.name), f.name
-end
-
-file package('.tar.gz') => %w[pkg/] + spec.files do |f|
-  sh <<-SH
-    git archive \
-      --prefix=sinatra-#{source_version}/ \
-      --format=tar \
-      HEAD | gzip > #{f.name}
-  SH
-end
-
-# Rubyforge Release / Publish Tasks ==================================
-
-desc 'Publish gem and tarball to rubyforge'
-task 'release' => [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
-
-# Website ============================================================
+# Website =============================================================
 # Building docs requires HAML and the hanna gem:
 #   gem install mislav-hanna --source=http://gems.github.com
 
+desc 'Generate RDoc under doc/api'
 task 'doc'     => ['doc:api']
 
-desc 'Generate Hanna RDoc under doc/api'
 task 'doc:api' => ['doc/api/index.html']
 
 file 'doc/api/index.html' => FileList['lib/**/*.rb','README.rdoc'] do |f|
@@ -101,31 +51,63 @@ file 'doc/api/index.html' => FileList['lib/**/*.rb','README.rdoc'] do |f|
 end
 CLEAN.include 'doc/api'
 
-# Gemspec Helpers ====================================================
+# PACKAGING ============================================================
 
-def source_version
-  line = File.read('lib/sinatra/base.rb')[/^\s*VERSION = .*/]
-  line.match(/.*VERSION = '(.*)'/)[1]
-end
+if defined?(Gem)
+  # Load the gemspec using the same limitations as github
+  def spec
+    require 'rubygems' unless defined? Gem::Specification
+    @spec ||= eval(File.read('sinatra.gemspec'))
+  end
+
+  def package(ext='')
+    "pkg/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 'pkg/'
+  CLOBBER.include('pkg')
 
-task 'sinatra.gemspec' => FileList['{lib,test,compat}/**','Rakefile','CHANGES','*.rdoc'] do |f|
-  # read spec file and split out manifest section
-  spec = File.read(f.name)
-  head, manifest, tail = spec.split("  # = MANIFEST =\n")
-  # replace version and date
-  head.sub!(/\.version = '.*'/, ".version = '#{source_version}'")
-  head.sub!(/\.date = '.*'/, ".date = '#{Date.today.to_s}'")
-  # determine file list from git ls-files
-  files = `git ls-files`.
-    split("\n").
-    sort.
-    reject{ |file| file =~ /^\./ }.
-    reject { |file| file =~ /^doc/ }.
-    map{ |file| "    #{file}" }.
-    join("\n")
-  # piece file back together and write...
-  manifest = "  s.files = %w[\n#{files}\n  ]\n"
-  spec = [head,manifest,tail].join("  # = MANIFEST =\n")
-  File.open(f.name, 'w') { |io| io.write(spec) }
-  puts "updated #{f.name}"
+  file package('.gem') => %w[pkg/ sinatra.gemspec] + spec.files do |f|
+    sh "gem build sinatra.gemspec"
+    mv File.basename(f.name), f.name
+  end
+
+  file package('.tar.gz') => %w[pkg/] + spec.files do |f|
+    sh <<-SH
+      git archive \
+        --prefix=sinatra-#{source_version}/ \
+        --format=tar \
+        HEAD | gzip > #{f.name}
+    SH
+  end
+
+  task 'sinatra.gemspec' => FileList['{lib,test,compat}/**','Rakefile','CHANGES','*.rdoc'] do |f|
+    # read spec file and split out manifest section
+    spec = File.read(f.name)
+    head, manifest, tail = spec.split("  # = MANIFEST =\n")
+    # replace version and date
+    head.sub!(/\.version = '.*'/, ".version = '#{source_version}'")
+    head.sub!(/\.date = '.*'/, ".date = '#{Date.today.to_s}'")
+    # determine file list from git ls-files
+    files = `git ls-files`.
+      split("\n").
+      sort.
+      reject{ |file| file =~ /^\./ }.
+      reject { |file| file =~ /^doc/ }.
+      map{ |file| "    #{file}" }.
+      join("\n")
+    # piece file back together and write...
+    manifest = "  s.files = %w[\n#{files}\n  ]\n"
+    spec = [head,manifest,tail].join("  # = MANIFEST =\n")
+    File.open(f.name, 'w') { |io| io.write(spec) }
+    puts "updated #{f.name}"
+  end
 end

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'
 
 enable :inline_templates

data/lib/sinatra/base.rb

@@ -5,34 +5,41 @@ require 'rack'
 require 'rack/builder'
 require 'sinatra/showexceptions'
 
-# Like Kernel#warn but outputs the location that triggered the warning.
-def sinatra_warn(*message) #:nodoc:
-  line = caller.
-    detect { |line| line !~ /(?:lib\/sinatra\/|__DELEGATE__)/ }.
-    sub(/:in .*/, '')
-  warn "#{line}: warning: #{message.join(' ')}"
+# require tilt if available; fall back on bundled version.
+begin
+  require 'tilt'
+rescue LoadError
+  require 'sinatra/tilt'
 end
 
 module Sinatra
-  VERSION = '0.9.6'
+  VERSION = '1.0.a'
 
   # The request object. See Rack::Request for more info:
   # http://rack.rubyforge.org/doc/classes/Rack/Request.html
   class Request < Rack::Request
-    def user_agent
-      @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
 
-    # Override Rack 0.9.x's #params implementation (see #72 in lighthouse)
-    def params
-      self.GET.update(self.POST)
-    rescue EOFError, Errno::ESPIPE
-      self.GET
+    def secure?
+      (@env['HTTP_X_FORWARDED_PROTO'] || @env['rack.url_scheme']) == 'https'
+    end
+
+    # Override Rack < 1.1's Request#params implementation (see lh #72 for
+    # more info) and add a Request#user_agent method.
+    # XXX remove when we require rack > 1.1
+    if Rack.release < '1.1'
+      def params
+        self.GET.update(self.POST)
+      rescue EOFError, Errno::ESPIPE
+        self.GET
+      end
+
+      def user_agent
+        @env['HTTP_USER_AGENT']
+      end
     end
   end
 
@@ -51,7 +58,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
@@ -62,7 +69,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)
@@ -116,11 +123,6 @@ module Sinatra
       Base.mime_type(type)
     end
 
-    def media_type(type)
-      sinatra_warn "media_type is deprecated; use mime_type instead"
-      mime_type(type)
-    end
-
     # Set the Content-Type of the response body given a media type or file
     # extension.
     def content_type(type, params={})
@@ -179,6 +181,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+.
@@ -221,7 +274,7 @@ module Sinatra
 
   end
 
-  # Template rendering methods. Each method takes a the name of a template
+  # 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.
   #
@@ -236,127 +289,76 @@ module Sinatra
   #                 in the template
   module Templates
     def erb(template, options={}, locals={})
-      require_warn('ERB') unless defined?(::ERB)
-
       render :erb, template, options, locals
     end
 
-    def haml(template, options={}, locals={})
-      require_warn('Haml') unless defined?(::Haml::Engine)
+    def erubis(template, options={}, locals={})
+      render :erubis, template, options, locals
+    end
 
+    def haml(template, options={}, locals={})
       render :haml, template, options, locals
     end
 
     def sass(template, options={}, locals={})
-      require_warn('Sass') unless defined?(::Sass::Engine)
-
       options[:layout] = false
       render :sass, template, options, locals
     end
 
     def builder(template=nil, options={}, locals={}, &block)
-      require_warn('Builder') unless defined?(::Builder)
-
       options, template = template, nil if template.is_a?(Hash)
-      template = lambda { block } if template.nil?
+      template = Proc.new { block } if template.nil?
       render :builder, template, options, locals
     end
 
   private
-    def render(engine, template, options={}, locals={})
+    def render(engine, data, options={}, locals={}, &block)
       # merge app-level options
-      options = self.class.send(engine).merge(options) if self.class.respond_to?(engine)
+      options = settings.send(engine).merge(options) if settings.respond_to?(engine)
 
       # 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
-      views = options.delete(:views) || self.class.views || "./views"
-      locals = options.delete(:locals) || locals || {}
 
-      # render template
-      data, options[:filename], options[:line] = lookup_template(engine, template, views)
-      output = __send__("render_#{engine}", template, data, options, locals)
+      # compile and render template
+      template = compile_template(engine, data, options, views)
+      output = template.render(self, locals, &block)
 
       # render layout
       if layout
-        data, options[:filename], options[:line] = lookup_layout(engine, layout, views)
-        if data
-          output = __send__("render_#{engine}", layout, data, options, locals) { output }
+        begin
+          options = options.merge(:views => views, :layout => false)
+          output = render(engine, layout, options, locals) { output }
+        rescue Errno::ENOENT
         end
       end
 
       output
     end
 
-    def lookup_template(engine, template, views_dir, filename = nil, line = nil)
-      case template
-      when Symbol
-        if cached = self.class.templates[template]
-          lookup_template(engine, cached[:template], views_dir, cached[:filename], cached[:line])
+    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
-          path = ::File.join(views_dir, "#{template}.#{engine}")
-          [ ::File.read(path), path, 1 ]
+          raise ArgumentError
         end
-      when Proc
-        filename, line = self.class.caller_locations.first if filename.nil?
-        [ template.call, filename, line.to_i ]
-      when String
-        filename, line = self.class.caller_locations.first if filename.nil?
-        [ template, filename, line.to_i ]
-      else
-        raise ArgumentError
       end
     end
-
-    def lookup_layout(engine, template, views_dir)
-      lookup_template(engine, template, views_dir)
-    rescue Errno::ENOENT
-      nil
-    end
-
-    def render_erb(template, data, options, locals, &block)
-      original_out_buf = defined?(@_out_buf) && @_out_buf
-      data = data.call if data.kind_of? Proc
-
-      instance = ::ERB.new(data, nil, nil, '@_out_buf')
-      locals_assigns = locals.to_a.collect { |k,v| "#{k} = locals[:#{k}]" }
-
-      filename = options.delete(:filename) || '(__ERB__)'
-      line = options.delete(:line) || 1
-      line -= 1 if instance.src =~ /^#coding:/
-
-      render_binding = binding
-      eval locals_assigns.join("\n"), render_binding
-      eval instance.src, render_binding, filename, line
-      @_out_buf, result = original_out_buf, @_out_buf
-      result
-    end
-
-    def render_haml(template, data, options, locals, &block)
-      ::Haml::Engine.new(data, options).render(self, locals, &block)
-    end
-
-    def render_sass(template, data, options, locals, &block)
-      ::Sass::Engine.new(data, options).render
-    end
-
-    def render_builder(template, data, options, locals, &block)
-      options = { :indent => 2 }.merge(options)
-      filename = options.delete(:filename) || '<BUILDER>'
-      line = options.delete(:line) || 1
-      xml = ::Builder::XmlMarkup.new(options)
-      if data.respond_to?(:to_str)
-        eval data.to_str, binding, filename, line
-      elsif data.kind_of?(Proc)
-        data.call(xml)
-      end
-      xml.target!
-    end
-
-    def require_warn(engine)
-      sinatra_warn "auto-require of #{engine} is deprecated; add require '#{engine}' to your app."
-      require engine.downcase
-    end
   end
 
   # Base class for all Sinatra applications and middleware.
@@ -369,6 +371,7 @@ module Sinatra
 
     def initialize(app=nil)
       @app = app
+      @template_cache = Tilt::Cache.new
       yield self if block_given?
     end
 
@@ -383,7 +386,8 @@ module Sinatra
       @env      = env
       @request  = Request.new(env)
       @response = Response.new
-      @params   = nil
+      @params   = indifferent_params(@request.params)
+      @template_cache.clear if settings.reload_templates
 
       invoke { dispatch! }
       invoke { error_block!(response.status) }
@@ -417,8 +421,8 @@ module Sinatra
     # Pass control to the next matching route.
     # If there are no more matching routes, Sinatra will
     # return a 404 response.
-    def pass
-      throw :pass
+    def pass(&block)
+      throw :pass, block
     end
 
     # Forward the request to the downstream app -- middleware only.
@@ -432,21 +436,21 @@ module Sinatra
     end
 
   private
-    # Run before filters and then locate and run a matching route.
-    def route!
-      # enable nested params in Rack < 1.0; allow indifferent access
-      @params =
-        if Rack::Utils.respond_to?(:parse_nested_query)
-          indifferent_params(@request.params)
-        else
-          nested_params(@request.params)
-        end
+    # 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)
 
@@ -471,15 +475,25 @@ 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 }
               route_eval(&block)
             end
           end
         end
+
+        @params = original_params
+      end
+
+      # 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
 
@@ -501,6 +515,20 @@ module Sinatra
       end
     end
 
+    # 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)
+
+      env['sinatra.static_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)
@@ -510,23 +538,6 @@ module Sinatra
       end
     end
 
-    # Recursively replace the params hash with a nested indifferent
-    # hash. Rack 1.0 has a built in implementation of this method - remove
-    # this once Rack 1.0 is required.
-    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
-      end
-    end
-
     def indifferent_hash
       Hash.new {|hash,key| hash[key.to_s] if Symbol === key }
     end
@@ -566,25 +577,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! unless env['sinatra.static_file']
     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? || options.show_exceptions?
+      dump_errors!(boom) if settings.dump_errors?
+      raise boom         if settings.raise_errors? || settings.show_exceptions?
 
       @response.status = 500
       error_block! boom.class, Exception
@@ -592,11 +608,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
@@ -606,11 +627,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/ ||
@@ -618,18 +639,43 @@ 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
+
+      # 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.
@@ -637,7 +683,7 @@ module Sinatra
         if value.kind_of?(Proc)
           metadef(option, &value)
           metadef("#{option}?") { !!__send__(option) }
-          metadef("#{option}=") { |val| metadef(option, &Proc.new{val}) }
+          metadef("#{option}=") { |val| set(option, Proc.new{val}) }
         elsif value == self && option.respond_to?(:to_hash)
           option.to_hash.each { |k,v| set(k, v) }
         elsif respond_to?("#{option}=")
@@ -662,11 +708,7 @@ module Sinatra
       # 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) { ... }`
@@ -677,7 +719,7 @@ module Sinatra
       # Define a named template. The block must return the template source.
       def template(name, &block)
         filename, line = caller_locations.first
-        templates[name] = { :filename => filename, :line => line, :template => block }
+        templates[name] = [block, filename, line.to_i]
       end
 
       # Define the layout template. The block must return the template source.
@@ -685,12 +727,6 @@ module Sinatra
         template name, &block
       end
 
-      def use_in_file_templates!(file=nil)
-        sinatra_warn "use_in_file_templates! is deprecated; " \
-          "use enable :inline_templates instead"
-        set :inline_templates, file
-      end
-
       # Load embeded templates from the file; uses the caller's __FILE__
       # when no file is specified.
       def inline_templates=(file=nil)
@@ -710,7 +746,7 @@ module Sinatra
             lines += 1
             if line =~ /^@@\s*(.*)/
               template = ''
-              templates[$1.to_sym] = { :filename => file, :line => lines, :template => template }
+              templates[$1.to_sym] = [template, file, lines]
             elsif template
               template << line
             end
@@ -726,16 +762,18 @@ module Sinatra
         Rack::Mime::MIME_TYPES[type] = value
       end
 
-      def media_type(type, value=nil)
-        sinatra_warn "media_type is deprecated; use mime_type instead"
-        mime_type(type, value)
+      # 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)
+        @before_filters << block
       end
 
-      # Define a before filter. Filters are run before all requests
-      # within the same context as route handlers and may access/modify the
-      # request and response.
-      def before(&block)
-        @filters << block
+      # 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
@@ -806,14 +844,14 @@ module Sinatra
         unbound_method = instance_method("#{verb} #{path}")
         block =
           if block.arity != 0
-            lambda { unbound_method.bind(self).call(*@block_params) }
+            proc { unbound_method.bind(self).call(*@block_params) }
           else
-            lambda { unbound_method.bind(self).call }
+            proc { unbound_method.bind(self).call }
           end
 
         invoke_hook(:route_added, verb, path, block)
 
-        (routes[verb] ||= []).
+        (@routes[verb] ||= []).
           push([pattern, keys, conditions, block]).last
       end
 
@@ -856,10 +894,6 @@ module Sinatra
         include(*extensions) if extensions.any?
       end
 
-      def extensions
-        (@extensions + (superclass.extensions rescue [])).uniq
-      end
-
       def register(*extensions, &block)
         extensions << Module.new(&block) if block_given?
         @extensions += extensions
@@ -899,6 +933,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}!"
@@ -914,12 +949,12 @@ 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::Session::Cookie if sessions?
         builder.use Rack::CommonLogger    if logging?
-        builder.use Rack::MethodOverride  if method_override?
+        builder.use Rack::MethodOverride  if methodoverride?
         builder.use ShowExceptions        if show_exceptions?
+        middleware.each { |c,a,b| builder.use(c, *a, &b) }
 
-        @middleware.each { |c,a,b| builder.use(c, *a, &b) }
         builder.run super
         builder.to_app
       end
@@ -928,25 +963,6 @@ module Sinatra
         synchronize { prototype.call(env) }
       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
-      end
-
     private
       def detect_rack_handler
         servers = Array(self.server)
@@ -961,7 +977,7 @@ module Sinatra
       end
 
       def inherited(subclass)
-        subclass.reset! self
+        subclass.reset!
         super
       end
 
@@ -981,11 +997,12 @@ module Sinatra
 
     public
       CALLERS_TO_IGNORE = [
-        /\/sinatra(\/(base|main|showexceptions|compat))?\.rb$/, # all sinatra code
+        /\/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
-      ] unless self.const_defined?('CALLERS_TO_IGNORE')
+      ]
 
       # add rubinius (and hopefully other VM impls) ignore patterns ...
       CALLERS_TO_IGNORE.concat(RUBY_IGNORE_CALLERS) if defined?(RUBY_IGNORE_CALLERS)
@@ -1004,6 +1021,8 @@ module Sinatra
       end
     end
 
+    reset!
+
     set :environment, (ENV['RACK_ENV'] || :development).to_sym
     set :raise_errors, Proc.new { !development? }
     set :dump_errors, Proc.new { development? }
@@ -1011,9 +1030,10 @@ module Sinatra
     set :clean_trace, true
     set :sessions, false
     set :logging, false
-    set :method_override, false
+    set :methodoverride, false
 
-    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
@@ -1021,24 +1041,11 @@ module Sinatra
     set :app_file, nil
     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 :static, Proc.new { self.public && File.exist?(self.public) }
+    set :reload_templates, Proc.new { !development? }
     set :lock, false
 
-    class << self
-      alias_method :methodoverride?, :method_override?
-      alias_method :methodoverride=, :method_override=
-    end
-
-    # 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 :public, Proc.new { root && File.join(root, 'public') }
+    set :static, Proc.new { self.public && File.exist?(self.public) }
 
     error ::Exception do
       response.status = 500
@@ -1080,24 +1087,6 @@ module Sinatra
     end
   end
 
-  # Deprecated as base class for non-top-level apps. Subclass
-  # Sinatra::Base instead and set options as needed.
-  class Default < Base
-    set :raise_errors, Proc.new { test? }
-    set :dump_errors, true
-    set :sessions, false
-    set :logging, Proc.new { ! test? }
-    set :method_override, true
-    set :run, Proc.new { ! test? }
-    set :static, true
-
-    def self.inherited(subclass)
-      sinatra_warn 'Sinatra::Default is deprecated; ' \
-                   'subclass Sinatra::Base instead'
-      super
-    end
-  end
-
   # Execution context for classic style (top-level) applications. All
   # DSL methods executed on main are delegated to this class.
   #
@@ -1110,7 +1099,7 @@ module Sinatra
     set :dump_errors, true
     set :sessions, false
     set :logging, Proc.new { ! test? }
-    set :method_override, true
+    set :methodoverride, true
     set :run, Proc.new { ! test? }
     set :static, true
 
@@ -1136,10 +1125,10 @@ module Sinatra
       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?,
-             :production?, :use_in_file_templates!, :helpers, :mime_type
+    delegate :get, :put, :post, :delete, :head, :template, :layout,
+             :before, :after, :error, :not_found, :configure, :set, :mime_type,
+             :enable, :disable, :use, :development?, :test?, :production?,
+             :helpers, :settings
   end
 
   # Create a new Sinatra application. The block is evaluated in the new app's
@@ -1160,13 +1149,3 @@ module Sinatra
     Application.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