sinatra 1.3.6 → 1.4.0.a

data/README.zh.rdoc

@@ -2,7 +2,7 @@
 <i>注：本文档仅仅是英文版的翻译，会出现内容没有及时更新的情况发生。
 如有不一致的地方，请以英文版为准。</i>
 
-Sinatra是一个基于Ruby语言，以最小精力为代价快速创建web应用为目的的DSL（
+Sinatra是一个基于Ruby语言，以最小精力为代价快速创建web应用为目的的{DSL}[http://en.wikipedia.org/wiki/Domain-specific_language]（
 领域专属语言）：
 
   # myapp.rb
@@ -15,7 +15,7 @@ Sinatra是一个基于Ruby语言，以最小精力为代价快速创建web应用
 安装gem然后运行：
 
   gem install sinatra
-  ruby -rubygems myapp.rb
+  ruby myapp.rb
 
 在该地址查看： http://localhost:4567
 
@@ -1016,7 +1016,7 @@ Sinatra并不理解。使用 +mime_type+ 通过文件扩展名来注册它们：
 
 这些辅助方法并不会为你做任何缓存，而是将必要的信息传送给你的缓存
 如果你在寻找缓存的快速解决方案，试试
-{rack-cache}[http://rtomayko.github.com/rack-cache/]:
+{rack-cache}[https://github.com/rtomayko/rack-cache]:
 
   require "rack/cache"
   require "sinatra"

data/Rakefile

@@ -1,4 +1,3 @@
-# encoding: UTF-8
 require 'rake/clean'
 require 'rake/testtask'
 require 'fileutils'
@@ -99,8 +98,8 @@ desc "list of contributors"
 task :thanks, [:release,:backports] do |t, a|
   a.with_defaults :release => "#{prev_version}..HEAD",
     :backports => "#{prev_feature}.0..#{prev_feature}.x"
-  included = `git log --format=format:"%aN\t%s" #{a.release}`.lines.map { |l| l.force_encoding('binary') }
-  excluded = `git log --format=format:"%aN\t%s" #{a.backports}`.lines.map { |l| l.force_encoding('binary') }
+  included = `git log --format=format:"%aN\t%s" #{a.release}`.lines.to_a
+  excluded = `git log --format=format:"%aN\t%s" #{a.backports}`.lines.to_a
   commits  = (included - excluded).group_by { |c| c[/^[^\t]+/] }
   authors  = commits.keys.sort_by { |n| - commits[n].size } - team
   puts authors[0..-2].join(', ') << " and " << authors.last,
@@ -167,7 +166,7 @@ if defined?(Gem)
 
   task 'release' => ['test', package('.gem')] do
     if File.binread("CHANGES") =~ /= \d\.\d\.\d . not yet released$/i
-      fail 'please update changes first'
+      fail 'please update changes first' unless %x{git symbolic-ref HEAD} == "refs/heads/prerelease\n"
     end
 
     sh <<-SH

data/examples/chat.rb

@@ -42,9 +42,6 @@ __END__
 
 @@ chat
 <pre id='chat'></pre>
-<form>
-  <input id='msg' placeholder='type message here...' />
-</form>
 
 <script>
   // reading
@@ -59,3 +56,6 @@ __END__
   });
 </script>
 
+<form>
+  <input id='msg' placeholder='type message here...' />
+</form>

data/lib/sinatra/base.rb

@@ -16,11 +16,14 @@ module Sinatra
   # The request object. See Rack::Request for more info:
   # http://rack.rubyforge.org/doc/classes/Rack/Request.html
   class Request < Rack::Request
+    HEADER_PARAM = /\s*[\w.]+=(?:[\w.]+|"(?:[^"\\]|\\.)*")?\s*/
+    HEADER_VALUE_WITH_PARAMS = /(?:(?:\w+|\*)\/(?:\w+|\*))\s*(?:;#{HEADER_PARAM})*/
+
     # Returns an array of acceptable media types for the response
     def accept
       @env['sinatra.accept'] ||= begin
-        entries = @env['HTTP_ACCEPT'].to_s.split(',')
-        entries.map { |e| accept_entry(e) }.sort_by(&:last).map(&:first)
+        entries = @env['HTTP_ACCEPT'].to_s.scan(HEADER_VALUE_WITH_PARAMS)
+        entries.map { |e| AcceptEntry.new(e) }.sort
       end
     end
 
@@ -50,11 +53,37 @@ module Sinatra
 
     private
 
-    def accept_entry(entry)
-      type, *options = entry.delete(' ').split(';')
-      quality = 0 # we sort smallest first
-      options.delete_if { |e| quality = 1 - e[2..-1].to_f if e.start_with? 'q=' }
-      [type, [quality, type.count('*'), 1 - options.size]]
+    class AcceptEntry
+      attr_accessor :params
+
+      def initialize(entry)
+        params = entry.scan(HEADER_PARAM).map do |s|
+          key, value = s.strip.split('=', 2)
+          value = value[1..-2].gsub(/\\(.)/, '\1') if value.start_with?('"')
+          [key, value]
+        end
+
+        @type = entry[/[^;]+/].delete(' ')
+        @params = Hash[params]
+        @q = @params.delete('q') { "1.0" }.to_f
+      end
+
+      def <=>(other)
+        other.priority <=> self.priority
+      end
+
+      def priority
+        # We sort in descending order; better matches should be higher.
+        [ @q, -@type.count('*'), @params.size ]
+      end
+
+      def [](param)
+        @params[param]
+      end
+
+      def to_str
+        @type
+      end
     end
   end
 
@@ -96,7 +125,7 @@ module Sinatra
         headers["Content-Length"] = body.inject(0) { |l, p| l + Rack::Utils.bytesize(p) }.to_s
       end
 
-      [status.to_i, headers, result]
+      [status.to_i, header, result]
     end
 
     private
@@ -130,7 +159,7 @@ module Sinatra
 
     private
 
-    def setup_close(env, status, headers, body)
+    def setup_close(env, status, header, body)
       return unless body.respond_to? :close and env.include? 'async.close'
       env['async.close'].callback { body.close }
       env['async.close'].errback { body.close }
@@ -164,24 +193,25 @@ module Sinatra
   end
 
   class NotFound < NameError #:nodoc:
-    def code ; 404 ; end
+    def http_status; 404 end
   end
 
   # Methods available to routes, before/after filters, and views.
   module Helpers
     # Set or retrieve the response status code.
-    def status(value=nil)
+    def status(value = nil)
       response.status = value if value
       response.status
     end
 
     # Set or retrieve the response body. When a block is given,
     # evaluation is deferred until the body is read with #each.
-    def body(value=nil, &block)
+    def body(value = nil, &block)
       if block_given?
         def block.each; yield(call) end
         response.body = block
       elsif value
+        headers.delete 'Content-Length' unless request.head?
         response.body = value
       else
         response.body
@@ -198,7 +228,7 @@ module Sinatra
 
       # According to RFC 2616 section 14.30, "the field value consists of a
       # single absolute URI"
-      response['Location'] = uri(uri, settings.absolute_redirects?, settings.prefixed_redirects?)
+      response['Location'] = uri(uri.to_s, settings.absolute_redirects?, settings.prefixed_redirects?)
       halt(*args)
     end
 
@@ -224,19 +254,19 @@ module Sinatra
     alias to uri
 
     # Halt processing and return the error status provided.
-    def error(code, body=nil)
+    def error(code, body = nil)
       code, body    = 500, code.to_str if code.respond_to? :to_str
       response.body = body unless body.nil?
       halt code
     end
 
     # Halt processing and return a 404 Not Found.
-    def not_found(body=nil)
+    def not_found(body = nil)
       error 404, body
     end
 
     # Set multiple response headers with Hash.
-    def headers(hash=nil)
+    def headers(hash = nil)
       response.headers.merge! hash if hash
       response.headers
     end
@@ -258,7 +288,7 @@ module Sinatra
 
     # Set the Content-Type of the response body given a media type or file
     # extension.
-    def content_type(type = nil, params={})
+    def content_type(type = nil, params = {})
       return response['Content-Type'] unless type
       default = params.delete :default
       mime_type = mime_type(type) || default
@@ -270,15 +300,18 @@ module Sinatra
       params.delete :charset if mime_type.include? 'charset'
       unless params.empty?
         mime_type << (mime_type.include?(';') ? ', ' : ';')
-        mime_type << params.map { |kv| kv.join('=') }.join(', ')
+        mime_type << params.map do |key, val|
+          val = val.inspect if val =~ /[";,]/
+          "#{key}=#{val}"
+        end.join(', ')
       end
       response['Content-Type'] = mime_type
     end
 
     # Set the Content-Disposition to "attachment" with the specified filename,
     # instructing the user agents to prompt to save.
-    def attachment(filename=nil)
-      response['Content-Disposition'] = 'attachment'
+    def attachment(filename = nil, disposition = 'attachment')
+      response['Content-Disposition'] = disposition.to_s
       if filename
         params = '; filename="%s"' % File.basename(filename)
         response['Content-Disposition'] << params
@@ -288,16 +321,16 @@ module Sinatra
     end
 
     # Use the contents of the file at +path+ as the response body.
-    def send_file(path, opts={})
+    def send_file(path, opts = {})
       if opts[:type] or not response['Content-Type']
         content_type opts[:type] || File.extname(path), :default => 'application/octet-stream'
       end
 
-      if opts[:disposition] == 'attachment' || opts[:filename]
-        attachment opts[:filename] || path
-      elsif opts[:disposition] == 'inline'
-        response['Content-Disposition'] = 'inline'
-      end
+      disposition = opts[:disposition]
+      filename    = opts[:filename]
+      disposition = 'attachment' if disposition.nil? and filename
+      filename    = path         if filename.nil?
+      attachment(filename, disposition) if disposition
 
       last_modified opts[:last_modified] if opts[:last_modified]
 
@@ -305,7 +338,8 @@ module Sinatra
       file.path = path
       result    = file.serving env
       result[1].each { |k,v| headers[k] ||= v }
-      halt result[0], result[2]
+      headers['Content-Length'] = result[1]['Content-Length']
+      halt opts[:status] || result[0], result[2]
     rescue Errno::ENOENT
       not_found
     end
@@ -356,6 +390,10 @@ module Sinatra
       end
 
       alias errback callback
+
+      def closed?
+        @closed
+      end
     end
 
     # Allows to start sending data to the client even though later parts of
@@ -575,7 +613,7 @@ module Sinatra
   #
   # Possible options are:
   #   :content_type   The content type to use, same arguments as content_type.
-  #   :layout         If set to false, no layout is rendered, otherwise
+  #   :layout         If set to something falsy, no layout is rendered, otherwise
   #                   the specified layout is used (Ignored for `sass` and `less`)
   #   :layout_engine  Engine to use for rendering the layout.
   #   :locals         A hash with local variables that should be available
@@ -593,82 +631,96 @@ module Sinatra
       @default_layout = :layout
     end
 
-    def erb(template, options={}, locals={})
-      render :erb, template, options, locals
+    def erb(template, options = {}, locals = {}, &block)
+      render(:erb, template, options, locals, &block)
     end
 
-    def erubis(template, options={}, locals={})
+    def erubis(template, options = {}, locals = {})
       warn "Sinatra::Templates#erubis is deprecated and will be removed, use #erb instead.\n" \
         "If you have Erubis installed, it will be used automatically."
       render :erubis, template, options, locals
     end
 
-    def haml(template, options={}, locals={})
-      render :haml, template, options, locals
+    def haml(template, options = {}, locals = {}, &block)
+      render(:haml, template, options, locals, &block)
     end
 
-    def sass(template, options={}, locals={})
+    def sass(template, options = {}, locals = {})
       options.merge! :layout => false, :default_content_type => :css
       render :sass, template, options, locals
     end
 
-    def scss(template, options={}, locals={})
+    def scss(template, options = {}, locals = {})
       options.merge! :layout => false, :default_content_type => :css
       render :scss, template, options, locals
     end
 
-    def less(template, options={}, locals={})
+    def less(template, options = {}, locals = {})
       options.merge! :layout => false, :default_content_type => :css
       render :less, template, options, locals
     end
 
-    def builder(template=nil, options={}, locals={}, &block)
+    def builder(template = nil, options = {}, locals = {}, &block)
       options[:default_content_type] = :xml
       render_ruby(:builder, template, options, locals, &block)
     end
 
-    def liquid(template, options={}, locals={})
-      render :liquid, template, options, locals
+    def liquid(template, options = {}, locals = {}, &block)
+      render(:liquid, template, options, locals, &block)
     end
 
-    def markdown(template, options={}, locals={})
+    def markdown(template, options = {}, locals = {})
       render :markdown, template, options, locals
     end
 
-    def textile(template, options={}, locals={})
+    def textile(template, options = {}, locals = {})
       render :textile, template, options, locals
     end
 
-    def rdoc(template, options={}, locals={})
+    def rdoc(template, options = {}, locals = {})
       render :rdoc, template, options, locals
     end
 
-    def radius(template, options={}, locals={})
+    def radius(template, options = {}, locals = {})
       render :radius, template, options, locals
     end
 
-    def markaby(template=nil, options={}, locals={}, &block)
+    def markaby(template = nil, options = {}, locals = {}, &block)
       render_ruby(:mab, template, options, locals, &block)
     end
 
-    def coffee(template, options={}, locals={})
+    def coffee(template, options = {}, locals = {})
       options.merge! :layout => false, :default_content_type => :js
       render :coffee, template, options, locals
     end
 
-    def nokogiri(template=nil, options={}, locals={}, &block)
+    def nokogiri(template = nil, options = {}, locals = {}, &block)
       options[:default_content_type] = :xml
       render_ruby(:nokogiri, template, options, locals, &block)
     end
 
-    def slim(template, options={}, locals={})
-      render :slim, template, options, locals
+    def slim(template, options = {}, locals = {}, &block)
+      render(:slim, template, options, locals, &block)
     end
 
-    def creole(template, options={}, locals={})
+    def creole(template, options = {}, locals = {})
       render :creole, template, options, locals
     end
 
+    def wlang(template, options = {}, locals = {}, &block)
+      render(:wlang, template, options, locals, &block)
+    end
+
+    def yajl(template, options = {}, locals = {})
+      options[:default_content_type] = :json
+      render :yajl, template, options, locals
+    end
+
+    def rabl(template, options = {}, locals = {})
+      Rabl.register!
+      render :rabl, template, options, locals
+    end
+
     # Calls the given block for every possible template file in views,
     # named name.ext, where ext is registered on engine.
     def find_template(views, name, engine)
@@ -679,29 +731,36 @@ module Sinatra
       end
     end
 
-  private
+    private
     # logic shared between builder and nokogiri
-    def render_ruby(engine, template, options={}, locals={}, &block)
+    def render_ruby(engine, template, options = {}, locals = {}, &block)
       options, template = template, nil if template.is_a?(Hash)
       template = Proc.new { block } if template.nil?
       render engine, template, options, locals
     end
 
-    def render(engine, data, options={}, locals={}, &block)
+    def render(engine, data, options = {}, locals = {}, &block)
       # merge app-level options
-      options = settings.send(engine).merge(options) if settings.respond_to?(engine)
-      options[:outvar]           ||= '@_out_buf'
-      options[:default_encoding] ||= settings.default_encoding
+      engine_options  = settings.respond_to?(engine) ? settings.send(engine) : {}
+      options         = engine_options.merge(options)
 
       # extract generic options
       locals          = options.delete(:locals) || locals         || {}
       views           = options.delete(:views)  || settings.views || "./views"
-      layout          = options.delete(:layout)
+      layout          = options[:layout]
+      layout          = false if layout.nil? && options.include?(:layout)
       eat_errors      = layout.nil?
-      layout          = @default_layout if layout.nil? or layout == true
-      content_type    = options.delete(:content_type)  || options.delete(:default_content_type)
-      layout_engine   = options.delete(:layout_engine) || engine
-      scope           = options.delete(:scope)         || self
+      layout          = engine_options[:layout] if layout.nil? or layout == true
+      layout          = @default_layout         if layout.nil? or layout == true
+      layout_options  = options.delete(:layout_options) || {}
+      content_type    = options.delete(:content_type)   || options.delete(:default_content_type)
+      layout_engine   = options.delete(:layout_engine)  || engine
+      scope           = options.delete(:scope)          || self
+      options.delete(:layout)
+
+      # set some defaults
+      options[:outvar]           ||= '@_out_buf'
+      options[:default_encoding] ||= settings.default_encoding
 
       # compile and render template
       begin
@@ -716,6 +775,7 @@ module Sinatra
       # render layout
       if layout
         options = options.merge(:views => views, :layout => false, :eat_errors => eat_errors, :scope => scope)
+        options.merge! layout_options
         catch(:layout_missing) { return render(layout_engine, layout, options, locals) { output } }
       end
 
@@ -725,7 +785,7 @@ module Sinatra
 
     def compile_template(engine, data, options, views)
       eat_errors = options.delete :eat_errors
-      template_cache.fetch engine, data, options do
+      template_cache.fetch engine, data, options, views do
         template = Tilt[engine]
         raise "Template engine not found: #{engine}" if template.nil?
 
@@ -768,7 +828,7 @@ module Sinatra
     attr_accessor :app
     attr_reader   :template_cache
 
-    def initialize(app=nil)
+    def initialize(app = nil)
       super()
       @app = app
       @template_cache = Tilt::Cache.new
@@ -792,7 +852,7 @@ module Sinatra
 
       @response['Content-Type'] = nil
       invoke { dispatch! }
-      invoke { error_block!(response.status) }
+      invoke { error_block!(response.status) } unless @env['sinatra.error']
 
       unless @response['Content-Type']
         if Array === body and body[0].respond_to? :content_type
@@ -846,165 +906,184 @@ module Sinatra
     end
 
   private
-    # Run filters defined on the class and all superclasses.
-    def filter!(type, base = settings)
-      filter! type, base.superclass if base.superclass.respond_to?(:filters)
-      base.filters[type].each { |args| process_route(*args) }
-    end
-
-    # Run routes defined on the class and all superclasses.
-    def route!(base = settings, pass_block=nil)
-      if routes = base.routes[@request.request_method]
-        routes.each do |pattern, keys, conditions, block|
-          pass_block = process_route(pattern, keys, conditions) do |*args|
-            route_eval { block[*args] }
-          end
-        end
-      end
+  # Run filters defined on the class and all superclasses.
+  def filter!(type, base = settings)
+    filter! type, base.superclass if base.superclass.respond_to?(:filters)
+    base.filters[type].each { |args| process_route(*args) }
+  end
 
-      # Run routes defined in superclass.
-      if base.superclass.respond_to?(:routes)
-        return route!(base.superclass, pass_block)
+  # Run routes defined on the class and all superclasses.
+  def route!(base = settings, pass_block = nil)
+    if routes = base.routes[@request.request_method]
+      routes.each do |pattern, keys, conditions, block|
+        pass_block = process_route(pattern, keys, conditions) do |*args|
+          route_eval { block[*args] }
+        end
       end
-
-      route_eval(&pass_block) if pass_block
-      route_missing
     end
 
-    # Run a route block and throw :halt with the result.
-    def route_eval
-      throw :halt, yield
+    # Run routes defined in superclass.
+    if base.superclass.respond_to?(:routes)
+      return route!(base.superclass, pass_block)
     end
 
-    # If the current request matches pattern and conditions, fill params
-    # with keys and call the given block.
-    # Revert params afterwards.
-    #
-    # Returns pass block.
-    def process_route(pattern, keys, conditions, block = nil, values = [])
-      route = @request.path_info
-      route = '/' if route.empty? and not settings.empty_path_info?
-      return unless match = pattern.match(route)
-      values += match.captures.to_a.map { |v| force_encoding URI.decode_www_form_component(v) if v }
+    route_eval(&pass_block) if pass_block
+    route_missing
+  end
 
-      if values.any?
-        original, @params = params, params.merge('splat' => [], 'captures' => values)
-        keys.zip(values) { |k,v| Array === @params[k] ? @params[k] << v : @params[k] = v if v }
-      end
+  # Run a route block and throw :halt with the result.
+  def route_eval
+    throw :halt, yield
+  end
 
-      catch(:pass) do
-        conditions.each { |c| throw :pass if c.bind(self).call == false }
-        block ? block[self, values] : yield(self, values)
-      end
-    ensure
-      @params = original if original
+  # If the current request matches pattern and conditions, fill params
+  # with keys and call the given block.
+  # Revert params afterwards.
+  #
+  # Returns pass block.
+  def process_route(pattern, keys, conditions, block = nil, values = [])
+    route = @request.path_info
+    route = '/' if route.empty? and not settings.empty_path_info?
+    return unless match = pattern.match(route)
+    values += match.captures.to_a.map { |v| force_encoding URI.decode_www_form_component(v) if v }
+
+    if values.any?
+      original, @params = params, params.merge('splat' => [], 'captures' => values)
+      keys.zip(values) { |k,v| Array === @params[k] ? @params[k] << v : @params[k] = v if v }
     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
-        raise NotFound
-      end
+    catch(:pass) do
+      conditions.each { |c| throw :pass if c.bind(self).call == false }
+      block ? block[self, values] : yield(self, values)
     end
+  ensure
+    @params = original if original
+  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_folder).nil?
-      public_dir = File.expand_path(public_dir)
+  # 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
+      raise NotFound
+    end
+  end
 
-      path = File.expand_path(public_dir + unescape(request.path_info))
-      return unless path.start_with?(public_dir) and File.file?(path)
+  # 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_folder).nil?
+    public_dir = File.expand_path(public_dir)
 
-      env['sinatra.static_file'] = path
-      cache_control(*settings.static_cache_control) if settings.static_cache_control?
-      send_file path, :disposition => nil
-    end
+    path = File.expand_path(public_dir + unescape(request.path_info))
+    return unless path.start_with?(public_dir) and File.file?(path)
 
-    # 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
+    env['sinatra.static_file'] = path
+    cache_control(*settings.static_cache_control) if settings.static_cache_control?
+    send_file path, :disposition => nil
+  end
 
-    # Creates a Hash with indifferent access.
-    def indifferent_hash
-      Hash.new {|hash,key| hash[key.to_s] if Symbol === key }
+  # Enable string or symbol key access to the nested params hash.
+  def indifferent_params(object)
+    case object
+    when Hash
+      new_hash = indifferent_hash
+      object.each { |key, value| new_hash[key] = indifferent_params(value) }
+      new_hash
+    when Array
+      object.map { |item| indifferent_params(item) }
+    else
+      object
     end
+  end
 
-    # Run the block with 'throw :halt' support and apply result to the response.
-    def invoke
-      res = catch(:halt) { yield }
-      res = [res] if Fixnum === res or String === res
-      if Array === res and Fixnum === res.first
-        status(res.shift)
-        body(res.pop)
-        headers(*res)
-      elsif res.respond_to? :each
-        body res
-      end
-      nil # avoid double setting the same response tuple twice
-    end
+  # Creates a Hash with indifferent access.
+  def indifferent_hash
+    Hash.new {|hash,key| hash[key.to_s] if Symbol === key }
+  end
 
-    # Dispatch a request with error handling.
-    def dispatch!
-      invoke do
-        static! if settings.static? && (request.get? || request.head?)
-        filter! :before
-        route!
-      end
-    rescue ::Exception => boom
-      invoke { handle_exception!(boom) }
-    ensure
-      filter! :after unless env['sinatra.static_file']
-    end
+  # Run the block with 'throw :halt' support and apply result to the response.
+  def invoke
+    res = catch(:halt) { yield }
+    res = [res] if Fixnum === res or String === res
+    if Array === res and Fixnum === res.first
+      res = res.dup
+      status(res.shift)
+      body(res.pop)
+      headers(*res)
+    elsif res.respond_to? :each
+      body res
+    end
+    nil # avoid double setting the same response tuple twice
+  end
 
-    # Error handling during requests.
-    def handle_exception!(boom)
-      @env['sinatra.error'] = boom
-      status boom.respond_to?(:code) ? Integer(boom.code) : 500
+  # Dispatch a request with error handling.
+  def dispatch!
+    invoke do
+      static! if settings.static? && (request.get? || request.head?)
+      filter! :before
+      route!
+    end
+  rescue ::Exception => boom
+    invoke { handle_exception!(boom) }
+  ensure
+    filter! :after unless env['sinatra.static_file']
+  end
 
-      if server_error?
-        dump_errors! boom if settings.dump_errors?
-        raise boom if settings.show_exceptions? and settings.show_exceptions != :after_handler
-      end
+  # Error handling during requests.
+  def handle_exception!(boom)
+    @env['sinatra.error'] = boom
 
-      if not_found?
-        headers['X-Cascade'] = 'pass'
-        body '<h1>Not Found</h1>'
-      end
+    if boom.respond_to? :http_status
+      status(boom.http_status)
+    elsif settings.use_code? and boom.respond_to? :code and boom.code.between? 400, 599
+      status(boom.code)
+    else
+      status(500)
+    end
 
-      res = error_block!(boom.class, boom) || error_block!(status, boom)
-      return res if res or not server_error?
-      raise boom if settings.raise_errors? or settings.show_exceptions?
-      error_block! Exception, boom
+    status(500) unless status.between? 400, 599
+
+    if server_error?
+      dump_errors! boom if settings.dump_errors?
+      raise boom if settings.show_exceptions? and settings.show_exceptions != :after_handler
+    end
+
+    if not_found?
+      headers['X-Cascade'] = 'pass' if settings.x_cascade?
+      body '<h1>Not Found</h1>'
     end
 
-    # Find an custom error block for the key(s) specified.
-    def error_block!(key, *block_params)
-      base = settings
-      while base.respond_to?(:errors)
-        next base = base.superclass unless args = base.errors[key]
+    res = error_block!(boom.class, boom) || error_block!(status, boom)
+    return res if res or not server_error?
+    raise boom if settings.raise_errors? or settings.show_exceptions?
+    error_block! Exception, boom
+  end
+
+  # Find an custom error block for the key(s) specified.
+  def error_block!(key, *block_params)
+    base = settings
+    while base.respond_to?(:errors)
+      next base = base.superclass unless args_array = base.errors[key]
+      args_array.reverse_each do |args|
+        first = args == args_array.first
         args += [block_params]
-        return process_route(*args)
+        resp = process_route(*args)
+        return resp unless resp.nil? && !first
       end
-      return false unless key.respond_to? :superclass and key.superclass < Exception
-      error_block!(key.superclass, *block_params)
     end
+    return false unless key.respond_to? :superclass and key.superclass < Exception
+    error_block!(key.superclass, *block_params)
+  end
 
-    def dump_errors!(boom)
-      msg = ["#{boom.class} - #{boom.message}:", *boom.backtrace].join("\n\t")
-      @env['rack.errors'].puts(msg)
-    end
+  def dump_errors!(boom)
+    msg = ["#{boom.class} - #{boom.message}:", *boom.backtrace].join("\n\t")
+    @env['rack.errors'].puts(msg)
+  end
 
     class << self
       attr_reader :routes, :filters, :templates, :errors
@@ -1099,12 +1178,13 @@ module Sinatra
         args  = compile! "ERROR", //, block
         codes = codes.map { |c| Array(c) }.flatten
         codes << Exception if codes.empty?
-        codes.each { |c| @errors[c] = args }
+        codes.each { |c| (@errors[c] ||= []) << args }
       end
 
       # Sugar for `error(404) { ... }`
       def not_found(&block)
-        error 404, &block
+        error(404, &block)
+        error(Sinatra::NotFound, &block)
       end
 
       # Define a named template. The block must return the template source.
@@ -1114,13 +1194,13 @@ module Sinatra
       end
 
       # Define the layout template. The block must return the template source.
-      def layout(name=:layout, &block)
+      def layout(name = :layout, &block)
         template name, &block
       end
 
       # Load embeded templates from the file; uses the caller's __FILE__
       # when no file is specified.
-      def inline_templates=(file=nil)
+      def inline_templates=(file = nil)
         file = (file.nil? || file == true) ? (caller_files.first || File.expand_path($0)) : file
 
         begin
@@ -1152,7 +1232,7 @@ module Sinatra
       end
 
       # Lookup or register a mime type in Rack's mime registry.
-      def mime_type(type, value=nil)
+      def mime_type(type, value = nil)
         return type if type.nil? || type.to_s.include?('/')
         type = ".#{type}" unless type.to_s[0] == ?.
         return Rack::Mime.mime_type(type, nil) unless value
@@ -1194,10 +1274,18 @@ module Sinatra
       end
 
       def public=(value)
-        warn ":public is no longer used to avoid overloading Module#public, use :public_folder instead"
+        warn ":public is no longer used to avoid overloading Module#public, use :public_dir instead"
         set(:public_folder, value)
       end
 
+      def public_dir=(value)
+        self.public_folder = value
+      end
+
+      def public_dir
+        public_folder
+      end
+
     private
       # Dynamically defines a method on settings.
       def define_singleton(name, content = Proc.new)
@@ -1232,8 +1320,11 @@ module Sinatra
         types.map! { |t| mime_types(t) }
         types.flatten!
         condition do
-          if type = request.preferred_type(types)
-            content_type(type)
+          if type = response['Content-Type']
+            types.include? type or types.include? type[/^[^;]+/]
+          elsif type = request.preferred_type(types)
+            params = (type.respond_to?(:params) ? type.params : {})
+            content_type(type, params)
             true
           else
             false
@@ -1244,7 +1335,7 @@ module Sinatra
     public
       # Defining a `GET` handler also automatically defines
       # a `HEAD` handler.
-      def get(path, opts={}, &block)
+      def get(path, opts = {}, &block)
         conditions = @conditions.dup
         route('GET', path, opts, &block)
 
@@ -1252,15 +1343,15 @@ 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 options(path, opts={}, &bk) route 'OPTIONS', path, opts, &bk end
-      def patch(path, opts={}, &bk)   route 'PATCH',   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
+      def options(path, opts = {}, &bk) route 'OPTIONS', path, opts, &bk end
+      def patch(path, opts = {}, &bk)   route 'PATCH',   path, opts, &bk end
 
     private
-      def route(verb, path, options={}, &block)
+      def route(verb, path, options = {}, &block)
         # Because of self.options.host
         host_name(options.delete(:host)) if options.key?(:host)
         enable :empty_path_info if path == "" and empty_path_info.nil?
@@ -1296,17 +1387,26 @@ module Sinatra
       def compile(path)
         keys = []
         if path.respond_to? :to_str
-          pattern = path.to_str.gsub(/[^\?\%\\\/\:\*\w]/) { |c| encoded(c) }
+          ignore = ""
+          pattern = path.to_str.gsub(/[^\?\%\\\/\:\*\w]/) do |c|
+            ignore << escaped(c).join if c.match(/[\.@]/)
+            patt = encoded(c)
+            patt.gsub(/%[\da-fA-F]{2}/) do |match|
+              match.split(//).map {|char| char =~ /[A-Z]/ ? "[#{char}#{char.tr('A-Z', 'a-z')}]" : char}.join
+            end
+          end
           pattern.gsub!(/((:\w+)|\*)/) do |match|
             if match == "*"
               keys << 'splat'
               "(.*?)"
             else
               keys << $2[1..-1]
-              "([^/?#]+)"
+              ignore_pattern = safe_ignore(ignore)
+
+              ignore_pattern
             end
           end
-          [/^#{pattern}$/, keys]
+          [/\A#{pattern}\z/, keys]
         elsif path.respond_to?(:keys) && path.respond_to?(:match)
           [path, path.keys]
         elsif path.respond_to?(:names) && path.respond_to?(:match)
@@ -1322,11 +1422,38 @@ module Sinatra
 
       def encoded(char)
         enc = URI.escape(char)
-        enc = "(?:#{Regexp.escape enc}|#{URI.escape char, /./})" if enc == char
+        enc = "(?:#{escaped(char, enc).join('|')})" if enc == char
         enc = "(?:#{enc}|#{encoded('+')})" if char == " "
         enc
       end
 
+      def escaped(char, enc = URI.escape(char))
+        [Regexp.escape(enc), URI.escape(char, /./)]
+      end
+
+      def safe_ignore(ignore)
+        unsafe_ignore = []
+        ignore = ignore.gsub(/%[\da-fA-F]{2}/) do |hex|
+          unsafe_ignore << hex[1..2]
+          ''
+        end
+        unsafe_patterns = unsafe_ignore.map do |unsafe|
+          chars = unsafe.split(//).map do |char|
+            if char =~ /[A-Z]/
+              char <<= char.tr('A-Z', 'a-z')
+            end
+            char
+          end
+
+          "|(?:%[^#{chars[0]}].|%[#{chars[0]}][^#{chars[1]}])"
+        end
+        if unsafe_patterns.length > 0
+          "((?:[^#{ignore}/?#%]#{unsafe_patterns.join()})+)"
+        else
+          "([^#{ignore}/?#]+)"
+        end
+      end
+
     public
       # Makes the methods defined in the block and in the Modules given
       # in `extensions` available to the handlers and templates
@@ -1369,13 +1496,14 @@ module Sinatra
       end
 
       # Run the Sinatra app as a self-hosted server using
-      # Thin, Mongrel or WEBrick (in that order). If given a block, will call
+      # Thin, Puma, Mongrel, or WEBrick (in that order). If given a block, will call
       # with the constructed handler once we have taken the stage.
-      def run!(options={})
+      def run!(options = {})
         set options
-        handler      = detect_rack_handler
-        handler_name = handler.name.gsub(/.*::/, '')
-        handler.run self, :Host => bind, :Port => port do |server|
+        handler         = detect_rack_handler
+        handler_name    = handler.name.gsub(/.*::/, '')
+        server_settings = settings.respond_to?(:server_settings) ? settings.server_settings : {}
+        handler.run self, server_settings.merge(:Port => port, :Host => bind) do |server|
           unless handler_name =~ /cgi/i
             $stderr.puts "== Sinatra/#{Sinatra::VERSION} has taken the stage " +
             "on #{port} for #{environment} with backup from #{handler_name}"
@@ -1401,15 +1529,17 @@ module Sinatra
       # pipeline. The object is guaranteed to respond to #call but may not be
       # an instance of the class new was called on.
       def new(*args, &bk)
-        build(Rack::Builder.new, *args, &bk).to_app
+        instance = new!(*args, &bk)
+        Wrapper.new(build(instance).to_app, instance)
       end
 
       # Creates a Rack::Builder instance with all the middleware set up and
-      # an instance of this class as end point.
-      def build(builder, *args, &bk)
+      # the given +app+ as end point.
+      def build(app)
+        builder = Rack::Builder.new
         setup_default_middleware builder
         setup_middleware builder
-        builder.run new!(*args, &bk)
+        builder.run app
         builder
       end
 
@@ -1460,8 +1590,9 @@ module Sinatra
       def setup_protection(builder)
         return unless protection?
         options = Hash === protection ? protection.dup : {}
+        protect_session  = options.fetch(:session) { sessions? }
         options[:except] = Array options[:except]
-        options[:except] += [:session_hijacking, :remote_token] unless sessions?
+        options[:except] += [:session_hijacking, :remote_token] unless protect_session
         options[:reaction] ||= :drop_session
         builder.use Rack::Protection, options
       end
@@ -1577,7 +1708,9 @@ module Sinatra
     set :logging, false
     set :protection, true
     set :method_override, false
+    set :use_code, false
     set :default_encoding, "utf-8"
+    set :x_cascade, true
     set :add_charset, %w[javascript xml xhtml+xml json].map { |t| "application/#{t}" }
     settings.add_charset << /^text\//
 
@@ -1597,9 +1730,21 @@ module Sinatra
 
     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 :bind, '0.0.0.0'
-    set :port, 4567
+    set :server, %w[http webrick]
+    set :bind, Proc.new { development? ? 'localhost' : '0.0.0.0' }
+    set :port, Integer(ENV['PORT'] || 4567)
+
+    ruby_engine = defined?(RUBY_ENGINE) && RUBY_ENGINE
+
+    if ruby_engine == 'macruby'
+      server.unshift 'control_tower'
+    else
+      server.unshift 'mongrel'  if ruby_engine.nil?
+      server.unshift 'puma'     if ruby_engine != 'rbx'
+      server.unshift 'thin'     if ruby_engine != 'jruby'
+      server.unshift 'puma'     if ruby_engine == 'rbx'
+      server.unshift 'trinidad' if ruby_engine =='jruby'
+    end
 
     set :absolute_redirects, true
     set :prefixed_redirects, false
@@ -1632,25 +1777,44 @@ module Sinatra
       error NotFound do
         content_type 'text/html'
 
-        (<<-HTML).gsub(/^ {8}/, '')
-        <!DOCTYPE html>
-        <html>
-        <head>
-          <style type="text/css">
-          body { text-align:center;font-family:helvetica,arial;font-size:22px;
-            color:#888;margin:20px}
-          #c {margin:0 auto;width:500px;text-align:left}
-          </style>
-        </head>
-        <body>
-          <h2>Sinatra doesn&rsquo;t know this ditty.</h2>
-          <img src='#{uri "/__sinatra__/404.png"}'>
-          <div id="c">
-            Try this:
-            <pre>#{request.request_method.downcase} '#{request.path_info}' do\n  "Hello World"\nend</pre>
-          </div>
-        </body>
-        </html>
+        if self.class == Sinatra::Application
+          code = <<-RUBY.gsub(/^ {12}/, '')
+            #{request.request_method.downcase} '#{request.path_info}' do
+              "Hello World"
+            end
+          RUBY
+        else
+          code = <<-RUBY.gsub(/^ {12}/, '')
+            class #{self.class}
+              #{request.request_method.downcase} '#{request.path_info}' do
+                "Hello World"
+              end
+            end
+          RUBY
+
+          file = settings.app_file.to_s.sub(settings.root.to_s, '').sub(/^\//, '')
+          code = "# in #{file}\n#{code}" unless file.empty?
+        end
+
+        (<<-HTML).gsub(/^ {10}/, '')
+          <!DOCTYPE html>
+          <html>
+          <head>
+            <style type="text/css">
+            body { text-align:center;font-family:helvetica,arial;font-size:22px;
+              color:#888;margin:20px}
+            #c {margin:0 auto;width:500px;text-align:left}
+            </style>
+          </head>
+          <body>
+            <h2>Sinatra doesn&rsquo;t know this ditty.</h2>
+            <img src='#{uri "/__sinatra__/404.png"}'>
+            <div id="c">
+              Try this:
+              <pre>#{code}</pre>
+            </div>
+          </body>
+          </html>
         HTML
       end
     end
@@ -1694,7 +1858,7 @@ module Sinatra
     delegate :get, :patch, :put, :post, :delete, :head, :options, :template, :layout,
              :before, :after, :error, :not_found, :configure, :set, :mime_type,
              :enable, :disable, :use, :development?, :test?, :production?,
-             :helpers, :settings
+             :helpers, :settings, :register
 
     class << self
       attr_accessor :target
@@ -1703,9 +1867,31 @@ module Sinatra
     self.target = Application
   end
 
+  class Wrapper
+    def initialize(stack, instance)
+      @stack, @instance = stack, instance
+    end
+
+    def settings
+      @instance.settings
+    end
+
+    def helpers
+      @instance
+    end
+
+    def call(env)
+      @stack.call(env)
+    end
+
+    def inspect
+      "#<#{@instance.class} app_file=#{settings.app_file.inspect}>"
+    end
+  end
+
   # Create a new Sinatra application. The block is evaluated in the new app's
   # class scope.
-  def self.new(base=Base, options={}, &block)
+  def self.new(base = Base, options = {}, &block)
     base = Class.new(base)
     base.class_eval(&block) if block_given?
     base