Syd-sinatra 0.9.0.2 → 0.9.0.4

data/AUTHORS

@@ -1,13 +1,13 @@
 Sinatra was designed and developed by Blake Mizerany (bmizerany) in
 California. Continued development would not be possible without the ongoing
-financial support provided by Heroku <heroku.com> and the emotional support
-provided by Adam Wiggins (adamwiggins), Chris Wanstrath (defunkt), PJ Hyett (pjhyett), and
-the rest of the Github crew.
+financial support provided by [Heroku](http://heroku.com) and the emotional
+support provided by Adam Wiggins (adamwiggins), Chris Wanstrath (defunkt),
+PJ Hyett (pjhyett), and the rest of the GitHub crew.
 
-Special thanks to the following extraordinary individuals, who-out which
+Special thanks to the following extraordinary individuals, without whom
 Sinatra would not be possible:
 
-* Ryan Tomayko (rtomayko) for constantly fixing whitespace errors 60d5006
+* Ryan Tomayko (rtomayko) for constantly fixing whitespace errors 60d5006   
 * Ezra Zygmuntowicz (ezmobius) for initial help and letting Blake steal
   some of merbs internal code.
 * Christopher Schneid (cschneid) for The Book, the blog (gittr.com),
@@ -16,7 +16,7 @@ Sinatra would not be possible:
   the README, and hanging in there when times were rough.
 * Simon Rozet (sr) for a ton of doc patches, HAML options, and all that
   advocacy stuff he's going to do for 1.0.
-* Erik Kastner (kastner) for fixing MIME_TYPES under Rack 0.5.
+* Erik Kastner (kastner) for fixing `MIME_TYPES` under Rack 0.5.
 * Ben Bleything (bleything) for caring about HTTP status codes and doc fixes.
 * Igal Koshevoy (igal) for root path detection under Thin/Passenger.
 * Jon Crosby (jcrosby) for coffee breaks, doc fixes, and just because, man.
@@ -27,12 +27,13 @@ Sinatra would not be possible:
 * Victor Hugo Borja (vic) for splat'n routes specs and doco.
 * Avdi Grimm (avdi) for basic RSpec support.
 * Jack Danger Canty for a more accurate root directory and for making me
-  watch this just now: http://www.youtube.com/watch?v=ueaHLHgskkw.
+  watch [this](http://www.youtube.com/watch?v=ueaHLHgskkw) just now.
 * Mathew Walker for making escaped paths work with static files.
 * Millions of Us for having the problem that led to Sinatra's conception.
 * Songbird for the problems that helped Sinatra's future become realized.
-* Rick Olsen (technoweenie) for the killer plug at RailsConf '08.
+* Rick Olson (technoweenie) for the killer plug at RailsConf '08.
 * Steven Garcia for the amazing custom artwork you see on 404's and 500's
+* Pat Nakajima (nakajima) for fixing non-nested params in nested params Hash's.
 
 and last but not least:
 

data/README.rdoc

@@ -10,12 +10,20 @@ effort:
     'Hello world!'
   end
 
-Run with <tt>ruby myapp.rb</tt> and view at <tt>http://localhost:4567</tt>
+Install the gem and run with:
 
-== HTTP Methods
+  sudo gem install sinatra
+  ruby myapp.rb
+
+View at: http://localhost:4567
+
+== Routes
+
+In Sinatra, a route is an HTTP method paired with an URL matching pattern.
+Each route is associated with a block:
 
   get '/' do
-    .. show things ..
+    .. show something ..
   end
 
   post '/' do
@@ -30,21 +38,13 @@ Run with <tt>ruby myapp.rb</tt> and view at <tt>http://localhost:4567</tt>
     .. annihilate something ..
   end
 
-== Routes
-
-Routes are matched based on the order of declaration. The first route that
+Routes are matched in the order they are defined. The first route that
 matches the request is invoked.
 
-Basic routes:
-
-  get '/hi' do
-    ...
-  end
-
 Route patterns may include named parameters, accessible via the
 <tt>params</tt> hash:
 
-  get '/:name' do
+  get '/hello/:name' do
     # matches "GET /foo" and "GET /bar"
     # params[:name] is 'foo' or 'bar'
     "Hello #{params[:name]}!"
@@ -86,9 +86,13 @@ a different location by setting the <tt>:public</tt> option:
 
   set :public, File.dirname(__FILE__) + '/static'
 
+Note that the public directory name is not included in the URL. A file
+<tt>./public/css/style.css</tt> is made available as
+<tt>http://example.com/css/style.css</tt>.
+
 == Views / Templates
 
-Templates are assumed to be located directly under a <tt>./views</tt>
+Templates are assumed to be located directly under the <tt>./views</tt>
 directory. To use a different views directory:
 
   set :views, File.dirname(__FILE__) + '/templates'
@@ -141,7 +145,7 @@ Renders <tt>./views/stylesheet.sass</tt>.
 
 Renders the inlined template string.
 
-=== Accessing Variables
+=== Accessing Variables in Templates
 
 Templates are evaluated within the same context as the route blocks. Instance
 variables set in route blocks are available in templates:
@@ -181,12 +185,13 @@ Templates may be defined at the end of the source file:
   @@ index
   %div.title Hello world!!!!!
 
-NOTE:  Sinatra will automaticly load any in-file-templates in the
-source file that first required sinatra.  If you have in-file-templates
-in another source file you will need to explicitly call
-+use_in_file_templates! on main in that file.
+NOTE: In-file templates defined in the source file that requires sinatra
+are automatically loaded. Call the <tt>use_in_file_templates!</tt>
+method explicitly if you have in-file templates in another source file.
 
-It's also possible to define named templates using the top-level template
+=== Named Templates
+
+It's possible to define named templates using the top-level <tt>template</tt>
 method:
 
   template :layout do
@@ -249,7 +254,7 @@ You can also specify a body when halting ...
 
   halt 'this will be the body'
 
-Set the status and body ...
+Or set the status and body ...
 
   halt 401, 'go away!'
 
@@ -317,7 +322,7 @@ code is 404, the <tt>not_found</tt> handler is invoked:
 
 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
-'sinatra.error' Rack variable:
+<tt>sinatra.error</tt> Rack variable:
 
   error do
     'Sorry there was a nasty error - ' + env['sinatra.error'].name
@@ -339,8 +344,8 @@ You get this:
 
   So what happened was... something bad
 
-Sinatra installs special not_found and error handlers when running under
-the development environment.
+Sinatra installs special <tt>not_found</tt> and <tt>error</tt> handlers when
+running under the development environment.
 
 == Mime types
 
@@ -480,73 +485,39 @@ Options are:
   -s # specify rack server/handler (default is thin)
   -x # turn on the mutex lock (default is off)
 
-== Contributing
-
-=== Tools
-
-Besides Ruby itself, you only need a text editor, preferably one that supports
-Ruby syntax hilighting. VIM and Emacs are a fine choice on any platform, but
-feel free to use whatever you're familiar with.
+== The Bleeding Edge
 
-Sinatra uses the Git source code management system. If you're unfamiliar with
-Git, you can find more information and tutorials on http://git.or.cz/ as well
-as http://git-scm.com/.  Scott Chacon created a great series of introductory
-screencasts about Git, which you can find here: http://www.gitcasts.com/
+If you would like to use Sinatra's latest bleeding code, create a local
+clone and run your app with the <tt>sinatra/lib</tt> directory on the
+<tt>LOAD_PATH</tt>:
 
-=== First Time: Cloning The Sinatra Repo
+  cd myapp
+  git clone git://github.com/sinatra/sinatra.git
+  ruby -Isinatra/lib myapp.rb
 
-  cd where/you/keep/your/projects
-  git clone git://github.com/bmizerany/sinatra.git
-  cd sinatra
-  cd path/to/your_project
-  ln -s ../sinatra/
-
-=== Updating Your Existing Sinatra Clone
-
-  cd where/you/keep/sinatra
-  git pull
-
-=== Using Edge Sinatra in Your App
-
-at the top of your sinatra_app.rb file:
+Alternatively, you can add the <tt>sinatra/lib<tt> directory to the
+<tt>LOAD_PATH</tt> in your application:
 
   $LOAD_PATH.unshift File.dirname(__FILE__) + '/sinatra/lib'
+  require 'rubygems'
   require 'sinatra'
 
   get '/about' do
-    "I'm running on Version " + Sinatra::VERSION
+    "I'm running version " + Sinatra::VERSION
   end
 
-=== Contributing a Patch
-
-There are several ways to do this. Probably the easiest (and preferred) way is
-to fork Sinatra on GitHub (http://github.com/bmizerany/sinatra), push your
-changes to your Sinatra repo, and then send Blake Mizerany (bmizerany on
-GitHub) a pull request.
-
-You can also create a patch file and attach it to a feature request or bug fix
-on the issue tracker (see below) or send it to the mailing list (see Community
-section).
+To update the Sinatra sources in the future:
 
-=== Issue Tracking and Feature Requests
-
-http://sinatra.lighthouseapp.com/
-
-== Community
-
-=== Mailing List
-
-http://groups.google.com/group/sinatrarb
-
-If you have a problem or question, please make sure to include all the
-relevant information in your mail, like the Sinatra version you're using, what
-version of Ruby you have, and so on.
-
-=== IRC Channel
+  cd myproject/sinatra
+  git pull
 
-You can find us on the Freenode network in the channel #sinatra
-(irc://chat.freenode.net/#sinatra)
+== More
 
-There's usually someone online at any given time, but we cannot pay attention
-to the channel all the time, so please stick around for a while after asking a
-question.
+* {Project Website}[http://sinatra.github.com/] - Additional documentation,
+  news, and links to other resources.
+* {Contributing}[http://sinatra.github.com/contribute.html] - Find a bug? Need
+  help? Have a patch?
+* {Lighthouse}[http://sinatra.lighthouseapp.com] - Issue tracking and release
+  planning.
+* {Mailing List}[http://groups.google.com/group/sinatrarb]
+* {IRC: #sinatra}[irc://chat.freenode.net/#sinatra] on http://freenode.net

data/Rakefile

@@ -1,23 +1,18 @@
-require 'rubygems'
 require 'rake/clean'
+require 'rake/testtask'
 require 'fileutils'
 
-task :default => :test
+task :default => [:compat, :test]
+task :spec => :test
 
 # SPECS ===============================================================
 
-desc 'Run specs with story style output'
-task :spec do
-  pattern = ENV['TEST'] || '.*'
-  sh "specrb --testcase '#{pattern}' --specdox -Ilib:test test/*_test.rb"
-end
-
-desc 'Run specs with unit test style output'
-task :test do |t|
-  sh "specrb -Ilib:test test/*_test.rb"
+Rake::TestTask.new(:test) do |t|
+  t.test_files = FileList['test/*_test.rb']
+  t.ruby_opts = ['-rubygems'] if defined? Gem
 end
 
-desc 'Run compatibility specs'
+desc 'Run compatibility specs (requires test/spec)'
 task :compat do |t|
   pattern = ENV['TEST'] || '.*'
   sh "specrb --testcase '#{pattern}' -Ilib:test compat/*_test.rb"
@@ -67,11 +62,6 @@ end
 
 # Rubyforge Release / Publish Tasks ==================================
 
-desc 'Publish website to rubyforge'
-task 'publish:doc' => 'doc/api/index.html' do
-  sh 'scp -rp doc/* rubyforge.org:/var/www/gforge-projects/sinatra/'
-end
-
 desc 'Publish gem and tarball to rubyforge'
 task 'publish:gem' => [package('.gem'), package('.tar.gz')] do |t|
   sh <<-end
@@ -84,7 +74,7 @@ end
 # Building docs requires HAML and the hanna gem:
 #   gem install mislav-hanna --source=http://gems.github.com
 
-task 'doc'     => ['doc:api','doc:site']
+task 'doc'     => ['doc:api']
 
 desc 'Generate Hanna RDoc under doc/api'
 task 'doc:api' => ['doc/api/index.html']
@@ -110,47 +100,6 @@ def rdoc_to_html(file_name)
   rdoc.convert(File.read(file_name))
 end
 
-def haml(locals={})
-  require 'haml'
-  template = File.read('doc/template.haml')
-  haml = Haml::Engine.new(template, :format => :html4, :attr_wrapper => '"')
-  haml.render(Object.new, locals)
-end
-
-desc 'Build website HTML and stuff'
-task 'doc:site' => ['doc/index.html', 'doc/book.html']
-
-file 'doc/index.html' => %w[README.rdoc doc/template.haml] do |file|
-  File.open(file.name, 'w') do |file|
-    file << haml(:title => 'Sinatra', :content => rdoc_to_html('README.rdoc'))
-  end
-end
-CLEAN.include 'doc/index.html'
-
-file 'doc/book.html' => ['book/output/sinatra-book.html'] do |file|
-  File.open(file.name, 'w') do |file|
-    book_content = File.read('book/output/sinatra-book.html')
-    file << haml(:title => 'Sinatra Book', :content => book_content)
-  end
-end
-CLEAN.include 'doc/book.html'
-
-file 'book/output/sinatra-book.html' => FileList['book/**'] do |f|
-  unless File.directory?('book')
-    sh 'git clone git://github.com/cschneid/sinatra-book.git book'
-  end
-  sh((<<-SH).strip.gsub(/\s+/, ' '))
-    cd book &&
-    git fetch origin &&
-    git rebase origin/master &&
-    thor book:build
-  SH
-end
-CLEAN.include 'book/output/sinatra-book.html'
-
-desc 'Build the Sinatra book'
-task 'doc:book' => ['book/output/sinatra-book.html']
-
 # Gemspec Helpers ====================================================
 
 def source_version

data/compat/app_test.rb

@@ -8,7 +8,8 @@ context "Sinatra" do
 
   specify "should put all DSL methods on (main)" do
     object = Object.new
-    Sinatra::Application::FORWARD_METHODS.each do |method|
+    methods = %w[get put post head delete configure template helpers set]
+    methods.each do |method|
       object.private_methods.should.include(method)
     end
   end

data/compat/streaming_test.rb

@@ -105,7 +105,7 @@ context "SendData" do
   end
 
   # Deprecated. The Content-Disposition is no longer handled by sendfile.
-  specify "should include a Content-Disposition header" do
+  xspecify "should include a Content-Disposition header" do
     get '/' do
       send_file File.dirname(__FILE__) + '/public/foo.xml'
     end
@@ -118,4 +118,16 @@ context "SendData" do
     headers['Content-Transfer-Encoding'].should.equal 'binary'
   end
 
+  specify "should include a Content-Disposition header when :disposition set to attachment" do
+    get '/' do
+      send_file File.dirname(__FILE__) + '/public/foo.xml',
+        :disposition => 'attachment'
+    end
+
+    get_it '/'
+
+    should.be.ok
+    headers['Content-Disposition'].should.not.be.nil
+    headers['Content-Disposition'].should.equal 'attachment; filename="foo.xml"'
+  end
 end

data/lib/sinatra/base.rb

@@ -125,15 +125,24 @@ module Sinatra
       end
     end
 
-    # Use the contents of the file as the response body and attempt to
+    # Use the contents of the file at +path+ as the response body.
     def send_file(path, opts={})
       stat = File.stat(path)
       last_modified stat.mtime
+
       content_type media_type(opts[:type]) ||
         media_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')
     rescue Errno::ENOENT
       not_found
@@ -142,6 +151,7 @@ module Sinatra
     class StaticFile < ::File #:nodoc:
       alias_method :to_path, :path
       def each
+        rewind
         while buf = read(8192)
           yield buf
         end
@@ -243,7 +253,6 @@ module Sinatra
       locals_assigns = locals.to_a.collect { |k,v| "#{k} = locals[:#{k}]" }
       src = "#{locals_assigns.join("\n")}\n#{instance.src}"
       eval src, binding, '(__ERB__)', locals_assigns.length + 1
-      instance.result(binding)
     end
 
     def haml(template, options={})
@@ -310,7 +319,11 @@ module Sinatra
       @request  = Request.new(env)
       @response = Response.new
       @params   = nil
-      error_detection { dispatch! }
+
+      invoke { dispatch! }
+      invoke { error_block!(response.status) }
+
+      @response.body = [] if @env['REQUEST_METHOD'] == 'HEAD'
       @response.finish
     end
 
@@ -319,7 +332,8 @@ module Sinatra
     end
 
     def halt(*response)
-      throw :halt, *response
+      response = response.first if response.length == 1
+      throw :halt, response
     end
 
     def pass
@@ -327,19 +341,21 @@ module Sinatra
     end
 
   private
-    def dispatch!
-      self.class.filters.each do |block|
-        res = catch(:halt) { instance_eval(&block) ; :continue }
-        return unless res == :continue
-      end
+    # Run before filters and then locate and run a matching route.
+    def route!
+      @params = nested_params(@request.params)
+
+      # before filters
+      self.class.filters.each { |block| instance_eval(&block) }
 
+      # routes
       if routes = self.class.routes[@request.request_method]
+        original_params = @params
         path = @request.path_info
-        original_params = nested_params(@request.params)
 
-        routes.each do |pattern, keys, conditions, method_name|
-          if pattern =~ path
-            values = $~.captures.map{|val| val && unescape(val) }
+        routes.each do |pattern, keys, conditions, block|
+          if match = pattern.match(path)
+            values = match.captures.map{|val| val && unescape(val) }
             params =
               if keys.any?
                 keys.zip(values).inject({}) do |hash,(k,v)|
@@ -357,24 +373,27 @@ module Sinatra
               end
             @params = original_params.merge(params)
 
-            catch(:pass) {
+            catch(:pass) do
               conditions.each { |cond|
                 throw :pass if instance_eval(&cond) == false }
-              return invoke(method_name)
-            }
+              throw :halt, instance_eval(&block)
+            end
           end
         end
       end
+
       raise NotFound
     end
 
     def nested_params(params)
       return indifferent_hash.merge(params) if !params.keys.join.include?('[')
       params.inject indifferent_hash do |res, (key,val)|
-        if key =~ /\[.*\]/
-          splat = key.scan(/(^[^\[]+)|\[([^\]]+)\]/).flatten.compact
-          head, last = splat[0..-2], splat[-1]
-          head.inject(res){ |s,v| s[v] ||= indifferent_hash }[last] = 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
@@ -384,7 +403,8 @@ module Sinatra
       Hash.new {|hash,key| hash[key.to_s] if Symbol === key }
     end
 
-    def invoke(block)
+    # Run the block with 'throw :halt' support and apply result to the response.
+    def invoke(&block)
       res = catch(:halt) { instance_eval(&block) }
       return if res.nil?
 
@@ -416,30 +436,48 @@ module Sinatra
       res
     end
 
-    def error_detection
-      errmap = self.class.errors
-      yield
+    # Dispatch a request with error handling.
+    def dispatch!
+      route!
     rescue NotFound => boom
       @env['sinatra.error'] = boom
       @response.status = 404
       @response.body = ['<h1>Not Found</h1>']
-      handler = errmap[boom.class] || errmap[NotFound]
-      invoke handler unless handler.nil?
+      error_block! boom.class, NotFound
+
     rescue ::Exception => boom
       @env['sinatra.error'] = boom
 
       if options.dump_errors?
-        msg = ["#{boom.class} - #{boom.message}:", *boom.backtrace].join("\n ")
-        @env['rack.errors'] << msg
+        backtrace = clean_backtrace(boom.backtrace)
+        msg = ["#{boom.class} - #{boom.message}:", *backtrace].join("\n ")
+        @env['rack.errors'].write(msg)
       end
 
       raise boom if options.raise_errors?
       @response.status = 500
-      invoke errmap[boom.class] || errmap[Exception]
-    ensure
-      if @response.status >= 400 && errmap.key?(response.status)
-        invoke errmap[response.status]
+      error_block! boom.class, Exception
+    end
+
+    # 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
+        end
       end
+      nil
+    end
+
+    def clean_backtrace(trace)
+      return trace unless options.clean_trace?
+
+      trace.reject { |line|
+        line =~ /lib\/sinatra.*\.rb/ ||
+          (defined?(Gem) && line.include?(Gem.dir))
+      }.map! { |line| line.gsub(/^\.\//, '') }
     end
 
     @routes     = {}
@@ -569,7 +607,7 @@ module Sinatra
         route('GET', path, opts, &block)
 
         @conditions = conditions
-        head(path, opts) { invoke(block) ; [] }
+        route('HEAD', path, opts, &block)
       end
 
       def put(path, opts={}, &bk); route 'PUT', path, opts, &bk; end
@@ -597,18 +635,22 @@ module Sinatra
       def compile(path)
         keys = []
         if path.respond_to? :to_str
+          special_chars = %w{. + ( )}
           pattern =
-            URI.encode(path).gsub(/((:\w+)|\*)/) do |match|
-              if match == "*"
+            URI.encode(path).gsub(/((:\w+)|[\*#{special_chars.join}])/) do |match|
+              case match
+              when "*"
                 keys << 'splat'
                 "(.*?)"
+              when *special_chars
+                Regexp.escape(match)
               else
                 keys << $2[1..-1]
                 "([^/?&#\.]+)"
               end
             end
           [/^#{pattern}$/, keys]
-        elsif path.respond_to? :=~
+        elsif path.respond_to? :match
           [path, keys]
         else
           raise TypeError, path
@@ -616,6 +658,11 @@ module Sinatra
       end
 
     public
+      def helpers(*modules, &block)
+        include *modules unless modules.empty?
+        class_eval(&block) if block
+      end
+
       def development? ; environment == :development ; end
       def test? ; environment == :test ; end
       def production? ; environment == :production ; end
@@ -630,8 +677,8 @@ module Sinatra
       end
 
       def run!(options={})
-        set(options)
-        handler = Rack::Handler.get(server)
+        set options
+        handler = detect_rack_handler
         handler_name = handler.name.gsub(/.*::/, '')
         puts "== Sinatra/#{Sinatra::VERSION} has taken the stage " +
           "on #{port} for #{environment} with backup from #{handler_name}"
@@ -652,6 +699,18 @@ module Sinatra
       end
 
     private
+      def detect_rack_handler
+        servers = Array(self.server)
+        servers.each do |server_name|
+          begin
+            return Rack::Handler.get(server_name)
+          rescue LoadError
+          rescue NameError
+          end
+        end
+        fail "Server handler (#{servers.join(',')}) not found."
+      end
+
       def construct_middleware(builder=Rack::Builder.new)
         builder.use Rack::Session::Cookie if sessions?
         builder.use Rack::CommonLogger if logging?
@@ -691,6 +750,7 @@ module Sinatra
 
     set :raise_errors, true
     set :dump_errors, false
+    set :clean_trace, true
     set :sessions, false
     set :logging, false
     set :methodoverride, false
@@ -698,7 +758,7 @@ module Sinatra
     set :environment, (ENV['RACK_ENV'] || :development).to_sym
 
     set :run, false
-    set :server, (defined?(Rack::Handler::Thin) ? "thin" : "mongrel")
+    set :server, %w[thin mongrel webrick]
     set :host, '0.0.0.0'
     set :port, 4567
 
@@ -771,7 +831,7 @@ module Sinatra
           <div id="c">
             <img src="/__sinatra__/500.png">
             <h1>#{escape_html(heading)}</h1>
-            <pre class='trace'>#{escape_html(err.backtrace.join("\n"))}</pre>
+            <pre>#{escape_html(clean_backtrace(err.backtrace) * "\n")}</pre>
             <h2>Params</h2>
             <pre>#{escape_html(params.inspect)}</pre>
           </div>
@@ -790,7 +850,8 @@ module Sinatra
     set :methodoverride, true
     set :static, true
     set :run, false
-    set :reload, Proc.new { app_file? && development? }
+    set :reload, Proc.new { app_file? && app_file !~ /\.ru$/i && development? }
+    set :lock, Proc.new { reload? }
 
     def self.reloading?
       @reloading ||= false
@@ -801,8 +862,10 @@ module Sinatra
     end
 
     def self.call(env)
-      reload! if reload?
-      super
+      synchronize do
+        reload! if reload?
+        super
+      end
     end
 
     def self.reload!
@@ -813,26 +876,36 @@ module Sinatra
       @reloading = false
     end
 
+  private
+    @@mutex = Mutex.new
+    def self.synchronize(&block)
+      if lock?
+        @@mutex.synchronize(&block)
+      else
+        yield
+      end
+    end
   end
 
   class Application < Default
   end
 
   module Delegator
-    METHODS = %w[
-      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!
-    ]
-
-    METHODS.each do |method_name|
-      eval <<-RUBY, binding, '(__DELEGATE__)', 1
-        def #{method_name}(*args, &b)
-          ::Sinatra::Application.#{method_name}(*args, &b)
-        end
-        private :#{method_name}
-      RUBY
+    def self.delegate(*methods)
+      methods.each do |method_name|
+        eval <<-RUBY, binding, '(__DELEGATE__)', 1
+          def #{method_name}(*args, &b)
+            ::Sinatra::Application.#{method_name}(*args, &b)
+          end
+          private :#{method_name}
+        RUBY
+      end
     end
+
+    delegate :get, :put, :post, :delete, :head, :template, :layout, :before,
+             :error, :not_found, :configures, :configure, :set, :set_option,
+             :set_options, :enable, :disable, :use, :development?, :test?,
+             :production?, :use_in_file_templates!, :helpers
   end
 
   def self.new(base=Base, options={}, &block)