sinatra 1.0 → 1.1.a

data/Rakefile

@@ -1,6 +1,7 @@
 require 'rake/clean'
 require 'rake/testtask'
 require 'fileutils'
+require 'date'
 
 task :default => :test
 task :spec => :test
@@ -12,9 +13,19 @@ end
 
 # SPECS ===============================================================
 
-Rake::TestTask.new(:test) do |t|
-  t.test_files = FileList['test/*_test.rb']
-  t.ruby_opts = ['-rubygems -I.'] if defined? Gem
+if !ENV['NO_TEST_FIX'] and RUBY_VERSION == '1.9.2' and RUBY_PATCHLEVEL == 0
+  # Avoids seg fault
+  task(:test) do
+    second_run  = %w[settings rdoc markaby].map { |l| "test/#{l}_test.rb" }
+    first_run   = Dir.glob('test/*_test.rb') - second_run
+    [first_run, second_run].each { |f| sh "testrb #{f.join ' '}" }
+  end
+else
+  Rake::TestTask.new(:test) do |t|
+    t.test_files = FileList['test/*_test.rb']
+    t.ruby_opts = ['-rubygems'] if defined? Gem
+    t.ruby_opts << '-I.'
+  end
 end
 
 # Rcov ================================================================
@@ -22,7 +33,7 @@ namespace :test do
   desc 'Mesures test coverage'
   task :coverage do
     rm_f "coverage"
-    rcov = "rcov --text-summary --test-unit-only -Ilib"
+    rcov = "rcov --text-summary -Ilib"
     system("#{rcov} --no-html --no-color test/*_test.rb")
   end
 end
@@ -36,11 +47,11 @@ task 'doc'     => ['doc:api']
 
 task 'doc:api' => ['doc/api/index.html']
 
-file 'doc/api/index.html' => FileList['lib/**/*.rb','README.rdoc'] do |f|
+file 'doc/api/index.html' => FileList['lib/**/*.rb', 'README.*'] do |f|
   require 'rbconfig'
   hanna = RbConfig::CONFIG['ruby_install_name'].sub('ruby', 'hanna')
   rb_files = f.prerequisites
-  sh((<<-end).gsub(/\s+/, ' '))
+  sh(<<-end.gsub(/\s+/, ' '))
     #{hanna}
       --charset utf8
       --fmt html

data/lib/sinatra/base.rb

@@ -4,48 +4,29 @@ require 'uri'
 require 'rack'
 require 'rack/builder'
 require 'sinatra/showexceptions'
-
-# require tilt if available; fall back on bundled version.
-begin
-  require 'tilt'
-  if Tilt::VERSION < '0.8'
-    warn "WARN: sinatra requires tilt >= 0.8; you have #{Tilt::VERSION}. " +
-         "loading bundled version..."
-    Object.send :remove_const, :Tilt
-    raise LoadError
-  end
-rescue LoadError
-  require 'sinatra/tilt'
-end
+require 'tilt'
 
 module Sinatra
-  VERSION = '1.0'
+  VERSION = '1.1.a'
 
   # The request object. See Rack::Request for more info:
   # http://rack.rubyforge.org/doc/classes/Rack/Request.html
   class Request < Rack::Request
     # Returns an array of acceptable media types for the response
     def accept
-      @env['HTTP_ACCEPT'].to_s.split(',').map { |a| a.strip }
+      @env['HTTP_ACCEPT'].to_s.split(',').map { |a| a.split(';')[0].strip }
     end
 
-    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']
+    if Rack.release <= "1.2"
+      # Whether or not the web server (or a reverse proxy in front of it) is
+      # using SSL to communicate with the client.
+      def secure?
+        @env['HTTPS'] == 'on' or
+        @env['HTTP_X_FORWARDED_PROTO'] == 'https' or
+        @env['rack.url_scheme'] == 'https'
       end
+    else
+      alias secure? ssl?
     end
   end
 
@@ -87,15 +68,30 @@ module Sinatra
     # evaluation is deferred until the body is read with #each.
     def body(value=nil, &block)
       if block_given?
-        def block.each ; yield call ; end
+        def block.each; yield(call) end
         response.body = block
-      else
+      elsif value
         response.body = value
+      else
+        response.body
       end
     end
 
     # Halt processing and redirect to the URI provided.
     def redirect(uri, *args)
+      if not uri =~ /^https?:\/\//
+        # According to RFC 2616 section 14.30, "the field value consists of a
+        # single absolute URI"
+        abs_uri = "#{request.scheme}://#{request.host}"
+
+        if request.scheme == 'https' && request.port != 443 ||
+              request.scheme == 'http' && request.port != 80
+          abs_uri << ":#{request.port}"
+        end
+
+        uri = (abs_uri << uri)
+      end
+
       status 302
       response['Location'] = uri
       halt(*args)
@@ -121,7 +117,7 @@ module Sinatra
 
     # Access the underlying Rack session.
     def session
-      env['rack.session'] ||= {}
+      request.session
     end
 
     # Look up a media type by file extension in Rack's mime registry.
@@ -132,8 +128,9 @@ module Sinatra
     # Set the Content-Type of the response body given a media type or file
     # extension.
     def content_type(type, params={})
-      mime_type = self.mime_type(type)
+      mime_type = mime_type(type)
       fail "Unknown media type: %p" % type if mime_type.nil?
+      params[:charset] ||= defined?(Encoding) ? Encoding.default_external.to_s.downcase : 'utf-8'
       if params.any?
         params = params.collect { |kv| "%s=%s" % kv }.join(', ')
         response['Content-Type'] = [mime_type, params].join(";")
@@ -158,19 +155,30 @@ module Sinatra
       last_modified stat.mtime
 
       content_type mime_type(opts[:type]) ||
+        opts[:type] ||
         mime_type(File.extname(path)) ||
         response['Content-Type'] ||
         'application/octet-stream'
 
-      response['Content-Length'] ||= (opts[:length] || stat.size).to_s
-
       if opts[:disposition] == 'attachment' || opts[:filename]
         attachment opts[:filename] || path
       elsif opts[:disposition] == 'inline'
         response['Content-Disposition'] = 'inline'
       end
 
-      halt StaticFile.open(path, 'rb')
+      file_length = opts[:length] || stat.size
+      sf = StaticFile.open(path, 'rb')
+      if ! sf.parse_ranges(env, file_length)
+        response['Content-Range'] = "bytes */#{file_length}"
+        halt 416
+      elsif r=sf.range
+        response['Content-Range'] = "bytes #{r.begin}-#{r.end}/#{file_length}"
+        response['Content-Length'] = (r.end - r.begin + 1).to_s
+        halt 206, sf
+      else
+        response['Content-Length'] ||= file_length.to_s
+        halt sf
+      end
     rescue Errno::ENOENT
       not_found
     end
@@ -179,10 +187,65 @@ module Sinatra
     # generated iteratively in 8K chunks.
     class StaticFile < ::File #:nodoc:
       alias_method :to_path, :path
+
+      attr_accessor :range  # a Range or nil
+
+      # Checks for byte-ranges in the request and sets self.range appropriately.
+      # Returns false if the ranges are unsatisfiable and the request should return 416.
+      def parse_ranges(env, size)
+        #r = Rack::Utils::byte_ranges(env, size)  # TODO: not available yet in released Rack
+        r = byte_ranges(env, size)
+        return false if r == []  # Unsatisfiable; report error
+        @range = r[0] if r && r.length == 1  # Ignore multiple-range requests for now
+        return true
+      end
+
+      # TODO: Copied from the new method Rack::Utils::byte_ranges; this method can be removed once
+      # a version of Rack with that method is released and Sinatra can depend on it.
+      def byte_ranges(env, size)
+        # See <http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.35>
+        http_range = env['HTTP_RANGE']
+        return nil unless http_range
+        ranges = []
+        http_range.split(/,\s*/).each do |range_spec|
+          matches = range_spec.match(/bytes=(\d*)-(\d*)/)
+          return nil  unless matches
+          r0,r1 = matches[1], matches[2]
+          if r0.empty?
+            return nil  if r1.empty?
+            # suffix-byte-range-spec, represents trailing suffix of file
+            r0 = [size - r1.to_i, 0].max
+            r1 = size - 1
+          else
+            r0 = r0.to_i
+            if r1.empty?
+              r1 = size - 1
+            else
+              r1 = r1.to_i
+              return nil  if r1 < r0  # backwards range is syntactically invalid
+              r1 = size-1  if r1 >= size
+            end
+          end
+          ranges << (r0..r1)  if r0 <= r1
+        end
+        ranges
+      end
+
+      CHUNK_SIZE = 8192
+
       def each
-        rewind
-        while buf = read(8192)
-          yield buf
+        if @range
+          self.pos = @range.begin
+          length = @range.end - @range.begin + 1
+          while length > 0 && (buf = read([CHUNK_SIZE,length].min))
+            yield buf
+            length -= buf.length
+          end
+        else
+          rewind
+          while buf = read(CHUNK_SIZE)
+            yield buf
+          end
         end
       end
     end
@@ -242,16 +305,16 @@ module Sinatra
     # and halt if conditional GET matches. The +time+ argument is a Time,
     # DateTime, or other object that responds to +to_time+.
     #
-    # When the current request includes an 'If-Modified-Since' header that
-    # matches the time specified, execution is immediately halted with a
-    # '304 Not Modified' response.
+    # When the current request includes an 'If-Modified-Since' header that is
+    # equal or later than the time specified, execution is immediately halted
+    # with a '304 Not Modified' response.
     def last_modified(time)
       return unless time
       time = time.to_time if time.respond_to?(:to_time)
-      time = time.httpdate if time.respond_to?(:httpdate)
-      response['Last-Modified'] = time
-      halt 304 if time == request.env['HTTP_IF_MODIFIED_SINCE']
-      time
+      time = Time.parse time.strftime('%FT%T%:z') if time.respond_to?(:strftime)
+      response['Last-Modified'] = time.respond_to?(:httpdate) ? time.httpdate : time.to_s
+      halt 304 if Time.httpdate(request.env['HTTP_IF_MODIFIED_SINCE']) >= time
+    rescue ArgumentError
     end
 
     # Set the response entity tag (HTTP 'ETag' header) and halt if conditional
@@ -295,15 +358,17 @@ module Sinatra
   #   :locals       A hash with local variables that should be available
   #                 in the template
   module Templates
+    module ContentTyped
+      attr_accessor :content_type
+    end
+
     include Tilt::CompileSite
 
     def erb(template, options={}, locals={})
-      options[:outvar] = '@_out_buf'
       render :erb, template, options, locals
     end
 
     def erubis(template, options={}, locals={})
-      options[:outvar] = '@_out_buf'
       render :erubis, template, options, locals
     end
 
@@ -312,35 +377,86 @@ module Sinatra
     end
 
     def sass(template, options={}, locals={})
-      options[:layout] = false
+      options.merge! :layout => false, :default_content_type => :css
       render :sass, template, options, locals
     end
 
+    def scss(template, options={}, locals={})
+      options.merge! :layout => false, :default_content_type => :css
+      render :scss, template, options, locals
+    end
+
     def less(template, options={}, locals={})
-      options[:layout] = false
+      options.merge! :layout => false, :default_content_type => :css
       render :less, template, options, locals
     end
 
     def builder(template=nil, options={}, locals={}, &block)
+      render_xml(:builder, template, options, locals, &block)
+    end
+
+    def liquid(template, options={}, locals={})
+      render :liquid, template, options, locals
+    end
+
+    def markdown(template, options={}, locals={})
+      render :markdown, template, options, locals
+    end
+
+    def textile(template, options={}, locals={})
+      render :textile, template, options, locals
+    end
+
+    def rdoc(template, options={}, locals={})
+      render :rdoc, template, options, locals
+    end
+
+    def radius(template, options={}, locals={})
+      render :radius, template, options, locals
+    end
+
+    def markaby(template, options={}, locals={})
+      render :mab, template, options, locals
+    end
+
+    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)
+      options[:layout] = false if Tilt::VERSION <= "1.1"
+      render_xml(:nokogiri, template, options, locals, &block)
+    end
+
+  private
+    # logic shared between builder and nokogiri
+    def render_xml(engine, template, options={}, locals={}, &block)
+      options[:default_content_type] = :xml
       options, template = template, nil if template.is_a?(Hash)
       template = Proc.new { block } if template.nil?
-      render :builder, template, options, locals
+      render engine, template, options, locals
     end
 
-  private
     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'
 
       # 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
+      locals          = options.delete(:locals) || locals         || {}
+      views           = options.delete(:views)  || settings.views || "./views"
+      @default_layout = :layout if @default_layout.nil?
+      layout          = options.delete(:layout)
+      layout          = @default_layout if layout.nil? or layout == true
+      content_type    = options.delete(:content_type) || options.delete(:default_content_type)
 
       # compile and render template
-      template = compile_template(engine, data, options, views)
-      output = template.render(self, locals, &block)
+      layout_was      = @default_layout
+      @default_layout = false if layout
+      template        = compile_template(engine, data, options, views)
+      output          = template.render(self, locals, &block)
+      @default_layout = layout_was
 
       # render layout
       if layout
@@ -351,11 +467,12 @@ module Sinatra
         end
       end
 
+      output.extend(ContentTyped).content_type = content_type if content_type
       output
     end
 
     def compile_template(engine, data, options, views)
-      @template_cache.fetch engine, data, options do
+      template_cache.fetch engine, data, options do
         template = Tilt[engine]
         raise "Template engine not found: #{engine}" if template.nil?
 
@@ -367,6 +484,11 @@ module Sinatra
             template.new(path, line.to_i, options) { body }
           else
             path = ::File.join(views, "#{data}.#{engine}")
+            Tilt.mappings.each do |ext, klass|
+              break if File.exists?(path)
+              next unless klass == template
+              path = ::File.join(views, "#{data}.#{ext}")
+            end
             template.new(path, 1, options)
           end
         when data.is_a?(Proc) || data.is_a?(String)
@@ -387,6 +509,7 @@ module Sinatra
     include Templates
 
     attr_accessor :app
+    attr_reader   :template_cache
 
     def initialize(app=nil)
       @app = app
@@ -401,15 +524,24 @@ module Sinatra
 
     attr_accessor :env, :request, :response, :params
 
-    def call!(env)
+    def call!(env) # :nodoc:
       @env      = env
       @request  = Request.new(env)
       @response = Response.new
       @params   = indifferent_params(@request.params)
-      @template_cache.clear if settings.reload_templates
+      template_cache.clear if settings.reload_templates
+      force_encoding(@params)
 
+      @response['Content-Type'] = nil
       invoke { dispatch! }
       invoke { error_block!(response.status) }
+      unless @response['Content-Type']
+        if body.respond_to?(:to_ary) and body.first.respond_to? :content_type
+          content_type body.first.content_type
+        else
+          content_type :html
+        end
+      end
 
       status, header, body = @response.finish
 
@@ -424,11 +556,20 @@ module Sinatra
       [status, header, body]
     end
 
+    # Access settings defined with Base.set.
+    def self.settings
+      self
+    end
+
     # Access settings defined with Base.set.
     def settings
-      self.class
+      self.class.settings
     end
+
     alias_method :options, :settings
+    class << self
+      alias_method :options, :settings
+    end
 
     # Exit the current block, halts any further processing
     # of the request, and returns the specified response.
@@ -455,64 +596,28 @@ module Sinatra
     end
 
   private
-    # 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
-
-    # 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) }
+    # Run filters defined on the class and all superclasses.
+    def filter!(type, base = self.class)
+      filter! type, base.superclass if base.superclass.respond_to?(:filters)
+      base.filters[type].each { |block| instance_eval(&block) }
     end
 
     # 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, keys, conditions, block|
-          if match = pattern.match(path)
-            values = match.captures.to_a
-            params =
-              if keys.any?
-                keys.zip(values).inject({}) do |hash,(k,v)|
-                  if k == 'splat'
-                    (hash[k] ||= []) << v
-                  else
-                    hash[k] = v
-                  end
-                  hash
-                end
-              elsif values.any?
-                {'captures' => values}
-              else
-                {}
-              end
-            @params = original_params.merge(params)
-            @block_params = values
-
-            pass_block = catch(:pass) do
-              conditions.each { |cond|
-                throw :pass if instance_eval(&cond) == false }
-              route_eval(&block)
-            end
+          pass_block = process_route(pattern, keys, conditions) do
+            route_eval(&block)
           end
         end
-
-        @params = original_params
       end
 
       # Run routes defined in superclass.
       if base.superclass.respond_to?(:routes)
-        route! base.superclass, pass_block
-        return
+        return route!(base.superclass, pass_block)
       end
 
       route_eval(&pass_block) if pass_block
-
       route_missing
     end
 
@@ -521,6 +626,46 @@ module Sinatra
       throw :halt, instance_eval(&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)
+      @original_params ||= @params
+      @path ||= begin
+        path = unescape(@request.path_info)
+        path.empty? ? "/" : path
+      end
+      if match = pattern.match(@path)
+        values = match.captures.to_a
+        params =
+          if keys.any?
+            keys.zip(values).inject({}) do |hash,(k,v)|
+              if k == 'splat'
+                (hash[k] ||= []) << v
+              else
+                hash[k] = v
+              end
+              hash
+            end
+          elsif values.any?
+            {'captures' => values}
+          else
+            {}
+          end
+        @params = @original_params.merge(params)
+        @block_params = values
+        catch(:pass) do
+          conditions.each { |cond|
+            throw :pass if instance_eval(&cond) == false }
+          yield
+        end
+      end
+    ensure
+      @params = @original_params
+    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
@@ -557,6 +702,7 @@ module Sinatra
       end
     end
 
+    # Creates a Hash with indifferent access.
     def indifferent_hash
       Hash.new {|hash,key| hash[key.to_s] if Symbol === key }
     end
@@ -587,7 +733,7 @@ module Sinatra
         end
       when res.respond_to?(:each)
         @response.body = res
-      when (100...599) === res
+      when (100..599) === res
         @response.status = res
       end
 
@@ -597,16 +743,17 @@ module Sinatra
     # Dispatch a request with error handling.
     def dispatch!
       static! if settings.static? && (request.get? || request.head?)
-      before_filter!
+      filter! :before
       route!
     rescue NotFound => boom
       handle_not_found!(boom)
     rescue ::Exception => boom
       handle_exception!(boom)
     ensure
-      after_filter! unless env['sinatra.static_file']
+      filter! :after unless env['sinatra.static_file']
     end
 
+    # Special treatment for 404s in order to play nice with cascades.
     def handle_not_found!(boom)
       @env['sinatra.error']          = boom
       @response.status               = 404
@@ -615,11 +762,12 @@ module Sinatra
       error_block! boom.class, NotFound
     end
 
+    # Error handling during requests.
     def handle_exception!(boom)
       @env['sinatra.error'] = boom
 
       dump_errors!(boom) if settings.dump_errors?
-      raise boom         if settings.show_exceptions?
+      raise boom if settings.show_exceptions? and settings.show_exceptions != :after_handler
 
       @response.status = 500
       if res = error_block!(boom.class)
@@ -644,6 +792,7 @@ module Sinatra
           end
         end
       end
+      raise boom if settings.show_exceptions? and keys == Exception
       nil
     end
 
@@ -654,13 +803,14 @@ module Sinatra
     end
 
     class << self
-      attr_reader :routes, :before_filters, :after_filters, :templates, :errors
+      attr_reader :routes, :filters, :templates, :errors
 
+      # Removes all routes, filters, middleware and extension hooks from the
+      # current class (not routes/filters/... defined by its superclass).
       def reset!
         @conditions     = []
         @routes         = {}
-        @before_filters = []
-        @after_filters  = []
+        @filters        = {:before => [], :after => []}
         @errors         = {}
         @middleware     = []
         @prototype      = nil
@@ -700,8 +850,8 @@ module Sinatra
           metadef(option, &value)
           metadef("#{option}?") { !!__send__(option) }
           metadef("#{option}=") { |val| metadef(option, &Proc.new{val}) }
-        elsif value == self && option.respond_to?(:to_hash)
-          option.to_hash.each { |k,v| set(k, v) }
+        elsif value == self && option.respond_to?(:each)
+          option.each { |k,v| set(k, v) }
         elsif respond_to?("#{option}=")
           __send__ "#{option}=", value
         else
@@ -746,7 +896,7 @@ module Sinatra
       # 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
+        file = (file.nil? || file == true) ? (caller_files.first || File.expand_path($0)) : file
 
         begin
           app, data =
@@ -760,7 +910,7 @@ module Sinatra
           template = nil
           data.each_line do |line|
             lines += 1
-            if line =~ /^@@\s*(.*)/
+            if line =~ /^@@\s*(.*\S)\s*$/
               template = ''
               templates[$1.to_sym] = [template, file, lines]
             elsif template
@@ -781,15 +931,24 @@ module Sinatra
       # 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
+      def before(path = nil, &block)
+        add_filter(:before, path, &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
+      def after(path = nil, &block)
+        add_filter(:after, path, &block)
+      end
+
+      # add a filter
+      def add_filter(type, path = nil, &block)
+        return filters[type] << block unless path
+        block, *arguments = compile!(type, path, block)
+        add_filter(type) do
+          process_route(*arguments) { instance_eval(&block) }
+        end
       end
 
       # Add a route condition. The route is considered non-matching when the
@@ -799,27 +958,30 @@ module Sinatra
       end
 
    private
+      # Condition for matching host name. Parameter might be String or Regexp.
       def host_name(pattern)
         condition { pattern === request.host }
       end
 
+      # Condition for matching user agent. Parameter should be Regexp.
+      # Will set params[:agent].
       def user_agent(pattern)
-        condition {
+        condition do
           if request.user_agent =~ pattern
             @params[:agent] = $~[1..-1]
             true
           else
             false
           end
-        }
+        end
       end
       alias_method :agent, :user_agent
 
+      # Condition for matching mimetypes. Accepts file extensions.
       def provides(*types)
-        types = [types] unless types.kind_of? Array
-        types.map!{|t| mime_type(t)}
+        types.map! { |t| mime_type(t) }
 
-        condition {
+        condition do
           matching_types = (request.accept & types)
           unless matching_types.empty?
             response.headers['Content-Type'] = matching_types.first
@@ -827,7 +989,7 @@ module Sinatra
           else
             false
           end
-        }
+        end
       end
 
     public
@@ -849,22 +1011,10 @@ module Sinatra
     private
       def route(verb, path, options={}, &block)
         # Because of self.options.host
-        host_name(options.delete(:bind)) if options.key?(:host)
-
-        options.each {|option, args| send(option, *args)}
-
-        pattern, keys = compile(path)
-        conditions, @conditions = @conditions, []
-
-        define_method "#{verb} #{path}", &block
-        unbound_method = instance_method("#{verb} #{path}")
-        block =
-          if block.arity != 0
-            proc { unbound_method.bind(self).call(*@block_params) }
-          else
-            proc { unbound_method.bind(self).call }
-          end
+        host_name(options.delete(:host)) if options.key?(:host)
+        options.each { |option, args| send(option, *args) }
 
+        block, pattern, keys, conditions = compile! verb, path, block
         invoke_hook(:route_added, verb, path, block)
 
         (@routes[verb] ||= []).
@@ -875,6 +1025,21 @@ module Sinatra
         extensions.each { |e| e.send(name, *args) if e.respond_to?(name) }
       end
 
+      def compile!(verb, path, block)
+        method_name = "#{verb} #{path}"
+
+        define_method(method_name, &block)
+        unbound_method          = instance_method method_name
+        pattern, keys           = compile(path)
+        conditions, @conditions = @conditions, []
+        remove_method method_name
+
+        [ block.arity != 0 ?
+            proc { unbound_method.bind(self).call(*@block_params) } :
+            proc { unbound_method.bind(self).call },
+          pattern, keys, conditions ]
+      end
+
       def compile(path)
         keys = []
         if path.respond_to? :to_str
@@ -889,7 +1054,7 @@ module Sinatra
                 Regexp.escape(match)
               else
                 keys << $2[1..-1]
-                "([^/?&#]+)"
+                "([^/?#]+)"
               end
             end
           [/^#{pattern}$/, keys]
@@ -910,6 +1075,8 @@ module Sinatra
         include(*extensions) if extensions.any?
       end
 
+      # Register an extension. Alternatively take a block from which an
+      # extension will be created and registered on the fly.
       def register(*extensions, &block)
         extensions << Module.new(&block) if block_given?
         @extensions += extensions
@@ -935,6 +1102,12 @@ module Sinatra
         @middleware << [middleware, args, block]
       end
 
+      def quit!(server, handler_name)
+        ## Use thins' hard #stop! if available, otherwise just #stop
+        server.respond_to?(:stop!) ? server.stop! : server.stop
+        puts "\n== Sinatra has ended his set (crowd applauds)" unless handler_name =~/cgi/i
+      end
+
       # Run the Sinatra app as a self-hosted server using
       # Thin, Mongrel or WEBrick (in that order)
       def run!(options={})
@@ -944,11 +1117,7 @@ module Sinatra
         puts "== Sinatra/#{Sinatra::VERSION} has taken the stage " +
           "on #{port} for #{environment} with backup from #{handler_name}" unless handler_name =~/cgi/i
         handler.run self, :Host => bind, :Port => port do |server|
-          trap(:INT) do
-            ## Use thins' hard #stop! if available, otherwise just #stop
-            server.respond_to?(:stop!) ? server.stop! : server.stop
-            puts "\n== Sinatra has ended his set (crowd applauds)" unless handler_name =~/cgi/i
-          end
+          [:INT, :TERM].each { |sig| trap(sig) { quit!(server, handler_name) } }
           set :running, true
         end
       rescue Errno::EADDRINUSE => e
@@ -981,7 +1150,7 @@ module Sinatra
 
     private
       def detect_rack_handler
-        servers = Array(self.server)
+        servers = Array(server)
         servers.each do |server_name|
           begin
             return Rack::Handler.get(server_name.downcase)
@@ -1012,12 +1181,13 @@ module Sinatra
       end
 
     public
-      CALLERS_TO_IGNORE = [
+      CALLERS_TO_IGNORE = [ # :nodoc:
         /\/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
+        /lib\/tilt.*\.rb$/,                              # all tilt code
+        /\(.*\)/,                                        # generated code
+        /rubygems\/custom_require\.rb$/,                 # rubygems require hacks
+        /active_support/,                                # active_support require hacks
+        /<internal:/,                                    # internal in ruby >= 1.9.2
       ]
 
       # add rubinius (and hopefully other VM impls) ignore patterns ...
@@ -1030,6 +1200,8 @@ module Sinatra
           map { |file,line| file }
       end
 
+      # Like caller_files, but containing Arrays rather than strings with the
+      # first element being the file, and the second being the line.
       def caller_locations
         caller(1).
           map    { |line| line.split(/:(?=\d|in )/)[0,2] }.
@@ -1037,6 +1209,33 @@ module Sinatra
       end
     end
 
+    # Fixes encoding issues by
+    # * defaulting to UTF-8
+    # * casting params to Encoding.default_external
+    #
+    # The latter might not be necessary if Rack handles it one day.
+    # Keep an eye on Rack's LH #100.
+    if defined? Encoding
+      if Encoding.default_external.to_s =~ /^ASCII/
+        Encoding.default_external = "UTF-8"
+      end
+      Encoding.default_internal ||= Encoding.default_external
+
+      def force_encoding(data)
+        return if data == self || data.is_a?(Tempfile)
+        if data.respond_to? :force_encoding
+          data.force_encoding(Encoding.default_external)
+        elsif data.respond_to? :each_value
+          data.each_value { |v| force_encoding(v) }
+        elsif data.respond_to? :each
+          data.each { |v| force_encoding(v) }
+        end
+      end
+    else
+      def force_encoding(*) end
+    end
+
+
     reset!
 
     set :environment, (ENV['RACK_ENV'] || :development).to_sym
@@ -1061,11 +1260,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 :reload_templates, Proc.new { development? }
+    set :reload_templates, Proc.new { development? or RUBY_VERSION < '1.8.7' }
     set :lock, false
 
     set :public, Proc.new { root && File.join(root, 'public') }
-    set :static, Proc.new { self.public && File.exist?(self.public) }
+    set :static, Proc.new { public && File.exist?(public) }
 
     error ::Exception do
       response.status = 500
@@ -1151,7 +1350,7 @@ module Sinatra
   # class scope.
   def self.new(base=Base, options={}, &block)
     base = Class.new(base)
-    base.send :class_eval, &block if block_given?
+    base.class_eval(&block) if block_given?
     base
   end