sinatra 1.4.2 → 1.4.3

data/README.hu.md

@@ -343,7 +343,7 @@ kérés alkalmával kiértékelődnek, így módosíthatják a kérést és a
 választ egyaránt. A szűrőkbe felvett példányváltozók elérhetőek lesznek
 az útvonalakban és a sablonokban is:
 
-```rubu
+```ruby
   before do
     @note = 'Csá!'
     request.path_info = '/foo/bar/baz'

data/README.md

@@ -2093,18 +2093,18 @@ set :protection, :session => true
   </dd>
 
   <dt>running</dt>
-  <dd>is the built-in server running now? do not change this setting!</dd>
+  <dd>is the built-in server running now? Do not change this setting!</dd>
 
   <dt>server</dt>
   <dd>
-    Server or list of servers to use for built-in server. order indicates priority,
-    default depends on Ruby implementation.
+    Server or list of servers to use for built-in server. Order indicates
+    priority, default depends on Ruby implementation.
   </dd>
 
   <dt>sessions</dt>
   <dd>
     Enable cookie-based sessions support using <tt>Rack::Session::Cookie</tt>.
-     See 'Using Sessions' section for more information.
+    See 'Using Sessions' section for more information.
   </dd>
 
   <dt>show_exceptions</dt>

data/README.pt-br.md

@@ -16,7 +16,7 @@ get '/' do
 end
 ```
 
-Instale a gem e execute como:
+Instale a gem e execute o arquivo criado acima:
 
 ``` shell
 gem install sinatra
@@ -25,8 +25,8 @@ ruby minhaapp.rb
 
 Acesse em: [localhost:4567](http://localhost:4567)
 
-Recomendamos a execução de `gem install thin`. Caso esteja disponível, o
-Sinatra irá usar.
+Recomendamos a execução de `gem install thin`. Caso esta gem esteja disponível, o
+Sinatra irá utilizá-la.
 
 ## Rotas
 
@@ -59,7 +59,7 @@ options '/' do
 end
 ```
 
-As rotas são interpretadas na ordem em que são definidos. A primeira
+As rotas são interpretadas na ordem em que são definidas. A primeira
 rota encontrada responde ao pedido.
 
 Padrões de rota podem conter parâmetros nomeados, acessível através do

data/lib/sinatra/base.rb

@@ -27,6 +27,10 @@ module Sinatra
       end
     end
 
+    def accept?(type)
+      preferred_type.include?(type)
+    end
+
     def preferred_type(*types)
       accepts = accept # just evaluate once
       return accepts.first if types.empty?
@@ -38,7 +42,6 @@ module Sinatra
       end
     end
 
-    alias accept? preferred_type
     alias secure? ssl?
 
     def forwarded?
@@ -106,7 +109,7 @@ module Sinatra
     end
   end
 
-  # The response object. See Rack::Response and Rack::ResponseHelpers for
+  # The response object. See Rack::Response and Rack::Response::Helpers for
   # more info:
   # http://rack.rubyforge.org/doc/classes/Rack/Response.html
   # http://rack.rubyforge.org/doc/classes/Rack/Response/Helpers.html
@@ -756,6 +759,7 @@ module Sinatra
     end
 
     private
+
     # logic shared between builder and nokogiri
     def render_ruby(engine, template, options = {}, locals = {}, &block)
       options, template = template, nil if template.is_a?(Hash)
@@ -849,7 +853,9 @@ module Sinatra
     include Helpers
     include Templates
 
-    attr_accessor :app
+    URI = ::URI.const_defined?(:Parser) ? ::URI::Parser.new : ::URI
+
+    attr_accessor :app, :env, :request, :response, :params
     attr_reader   :template_cache
 
     def initialize(app = nil)
@@ -864,8 +870,6 @@ module Sinatra
       dup.call!(env)
     end
 
-    attr_accessor :env, :request, :response, :params
-
     def call!(env) # :nodoc:
       @env      = env
       @request  = Request.new(env)
@@ -929,191 +933,210 @@ module Sinatra
       nil
     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
+    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] }
+    # 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|
+            env['sinatra.route'] = block.instance_variable_get(:@route_name)
+            route_eval { block[*args] }
+          end
         end
       end
-    end
 
-    # Run routes defined in superclass.
-    if base.superclass.respond_to?(:routes)
-      return route!(base.superclass, pass_block)
-    end
+      # Run routes defined in superclass.
+      if base.superclass.respond_to?(:routes)
+        return route!(base.superclass, pass_block)
+      end
 
-    route_eval(&pass_block) if pass_block
-    route_missing
-  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
-  end
+    # Run a route block and throw :halt with the result.
+    def route_eval
+      throw :halt, yield
+    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(v) if v }
+    # 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.unescape(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
+      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
 
-    catch(:pass) do
-      conditions.each { |c| throw :pass if c.bind(self).call == false }
-      block ? block[self, values] : yield(self, values)
+      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
-  ensure
-    @params = original if original
-  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
+    # 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
-  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)
 
-    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(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
+      env['sinatra.static_file'] = path
+      cache_control(*settings.static_cache_control) if settings.static_cache_control?
+      send_file path, :disposition => nil
     end
-  end
 
-  # Creates a Hash with indifferent access.
-  def indifferent_hash
-    Hash.new {|hash,key| hash[key.to_s] if Symbol === key }
-  end
+    # 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
-      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
+    # 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!
+    # 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
-  rescue ::Exception => boom
-    invoke { handle_exception!(boom) }
-  ensure
-    begin
-      filter! :after unless env['sinatra.static_file']
+
+    # 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) } unless @env['sinatra.error']
+      invoke { handle_exception!(boom) }
+    ensure
+      begin
+        filter! :after unless env['sinatra.static_file']
+      rescue ::Exception => boom
+        invoke { handle_exception!(boom) } unless @env['sinatra.error']
+      end
     end
-  end
 
-  # Error handling during requests.
-  def handle_exception!(boom)
-    @env['sinatra.error'] = boom
+    # Error handling during requests.
+    def handle_exception!(boom)
+      @env['sinatra.error'] = boom
 
-    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
+      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
 
-    status(500) unless status.between? 400, 599
+      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 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
+      if not_found?
+        headers['X-Cascade'] = 'pass' if settings.x_cascade?
+        body '<h1>Not Found</h1>'
+      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
-  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
+    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]
-        resp = process_route(*args)
-        return resp unless resp.nil? && !first
+    # 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]
+          resp = process_route(*args)
+          return resp unless resp.nil? && !first
+        end
       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
+      CALLERS_TO_IGNORE = [ # :nodoc:
+        /\/sinatra(\/(base|main|showexceptions))?\.rb$/,    # all sinatra code
+        /lib\/tilt.*\.rb$/,                                 # all tilt code
+        /^\(.*\)$/,                                         # generated code
+        /rubygems\/(custom|core_ext\/kernel)_require\.rb$/, # rubygems require hacks
+        /active_support/,                                   # active_support require hacks
+        /bundler(\/runtime)?\.rb/,                          # bundler require hacks
+        /<internal:/,                                       # internal in ruby >= 1.9.2
+        /src\/kernel\/bootstrap\/[A-Z]/                     # maglev kernel files
+      ]
+
+      # contrary to what the comment said previously, rubinius never supported this
+      if defined?(RUBY_IGNORE_CALLERS)
+        warn "RUBY_IGNORE_CALLERS is deprecated and will no longer be supported by Sinatra 2.0"
+        CALLERS_TO_IGNORE.concat(RUBY_IGNORE_CALLERS)
+      end
+
       attr_reader :routes, :filters, :templates, :errors
 
       # Removes all routes, filters, middleware and extension hooks from the
@@ -1315,7 +1338,131 @@ module Sinatra
         public_folder
       end
 
-    private
+      # Defining a `GET` handler also automatically defines
+      # a `HEAD` handler.
+      def get(path, opts = {}, &block)
+        conditions = @conditions.dup
+        route('GET', path, opts, &block)
+
+        @conditions = conditions
+        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 link(path, opts = {}, &bk)    route 'LINK',    path, opts, &bk end
+      def unlink(path, opts = {}, &bk)  route 'UNLINK',  path, opts, &bk end
+
+      # Makes the methods defined in the block and in the Modules given
+      # in `extensions` available to the handlers and templates
+      def helpers(*extensions, &block)
+        class_eval(&block)   if block_given?
+        include(*extensions) if extensions.any?
+      end
+
+      # 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
+        extensions.each do |extension|
+          extend extension
+          extension.registered(self) if extension.respond_to?(:registered)
+        end
+      end
+
+      def development?; environment == :development end
+      def production?;  environment == :production  end
+      def test?;        environment == :test        end
+
+      # Set configuration options for Sinatra and/or the app.
+      # Allows scoping of settings for certain environments.
+      def configure(*envs, &block)
+        yield self if envs.empty? || envs.include?(environment.to_sym)
+      end
+
+      # Use the specified Rack middleware
+      def use(middleware, *args, &block)
+        @prototype = nil
+        @middleware << [middleware, args, block]
+      end
+
+      def quit!(server, handler_name)
+        # Use Thin's hard #stop! if available, otherwise just #stop.
+        server.respond_to?(:stop!) ? server.stop! : server.stop
+        $stderr.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, 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 = {})
+        set options
+        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}"
+          end
+          [:INT, :TERM].each { |sig| trap(sig) { quit!(server, handler_name) } }
+          server.threaded = settings.threaded if server.respond_to? :threaded=
+          set :running, true
+          yield server if block_given?
+        end
+      rescue Errno::EADDRINUSE
+        $stderr.puts "== Someone is already performing on port #{port}!"
+      end
+
+      # The prototype instance used to process requests.
+      def prototype
+        @prototype ||= new
+      end
+
+      # Create a new instance without middleware in front of it.
+      alias new! new unless method_defined? :new!
+
+      # Create a new instance of the class fronted by its middleware
+      # 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)
+        instance = new!(*args, &bk)
+        Wrapper.new(build(instance).to_app, instance)
+      end
+
+      # Creates a Rack::Builder instance with all the middleware set up and
+      # the given +app+ as end point.
+      def build(app)
+        builder = Rack::Builder.new
+        setup_default_middleware builder
+        setup_middleware builder
+        builder.run app
+        builder
+      end
+
+      def call(env)
+        synchronize { prototype.call(env) }
+      end
+
+      # Like Kernel#caller but excluding certain magic entries and without
+      # line / method information; the resulting array contains filenames only.
+      def caller_files
+        cleaned_caller(1).flatten
+      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
+        cleaned_caller 2
+      end
+
+      private
+
       # Dynamically defines a method on settings.
       def define_singleton(name, content = Proc.new)
         # replace with call to singleton_class once we're 1.9 only
@@ -1361,27 +1508,6 @@ module Sinatra
         end
       end
 
-    public
-      # Defining a `GET` handler also automatically defines
-      # a `HEAD` handler.
-      def get(path, opts = {}, &block)
-        conditions = @conditions.dup
-        route('GET', path, opts, &block)
-
-        @conditions = conditions
-        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 link(path, opts = {}, &bk)    route 'LINK',    path, opts, &bk end
-      def unlink(path, opts = {}, &bk)  route 'UNLINK',  path, opts, &bk end
-
-    private
       def route(verb, path, options = {}, &block)
         # Because of self.options.host
         host_name(options.delete(:host)) if options.key?(:host)
@@ -1410,27 +1536,30 @@ module Sinatra
         pattern, keys           = compile path
         conditions, @conditions = @conditions, []
 
-        [ pattern, keys, conditions, block.arity != 0 ?
-            proc { |a,p| unbound_method.bind(a).call(*p) } :
-            proc { |a,p| unbound_method.bind(a).call } ]
+        wrapper                 = block.arity != 0 ?
+          proc { |a,p| unbound_method.bind(a).call(*p) } :
+          proc { |a,p| unbound_method.bind(a).call }
+        wrapper.instance_variable_set(:@route_name, method_name)
+
+        [ pattern, keys, conditions, wrapper ]
       end
 
       def compile(path)
         if path.respond_to? :to_str
           keys = []
-          
+
           # We append a / at the end if there was one.
           # Reason: Splitting does not split off an empty
           # string at the end if the split separator
           # is at the end.
           #
           postfix = '/' if path =~ /\/\z/
-          
+
           # Split the path into pieces in between forward slashes.
           #
           segments = path.split('/').map! do |segment|
             ignore = []
-            
+
             # Special character handling.
             #
             pattern = segment.to_str.gsub(/[^\?\%\\\/\:\*\w]/) do |c|
@@ -1440,9 +1569,9 @@ module Sinatra
                 match.split(//).map {|char| char =~ /[A-Z]/ ? "[#{char}#{char.tr('A-Z', 'a-z')}]" : char}.join
               end
             end
-            
+
             ignore = ignore.uniq.join
-            
+
             # Key handling.
             #
             pattern.gsub(/((:\w+)|\*)/) do |match|
@@ -1452,12 +1581,12 @@ module Sinatra
               else
                 keys << $2[1..-1]
                 ignore_pattern = safe_ignore(ignore)
-                
+
                 ignore_pattern
               end
             end
           end
-          
+
           # Special case handling.
           #
           if segment = segments.pop
@@ -1481,8 +1610,6 @@ module Sinatra
         end
       end
 
-      URI = ::URI.const_defined?(:Parser) ? ::URI::Parser.new : ::URI
-
       def encoded(char)
         enc = URI.escape(char)
         enc = "(?:#{escaped(char, enc).join('|')})" if enc == char
@@ -1517,100 +1644,6 @@ module Sinatra
         end
       end
 
-    public
-      # Makes the methods defined in the block and in the Modules given
-      # in `extensions` available to the handlers and templates
-      def helpers(*extensions, &block)
-        class_eval(&block)   if block_given?
-        include(*extensions) if extensions.any?
-      end
-
-      # 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
-        extensions.each do |extension|
-          extend extension
-          extension.registered(self) if extension.respond_to?(:registered)
-        end
-      end
-
-      def development?; environment == :development end
-      def production?;  environment == :production  end
-      def test?;        environment == :test        end
-
-      # Set configuration options for Sinatra and/or the app.
-      # Allows scoping of settings for certain environments.
-      def configure(*envs, &block)
-        yield self if envs.empty? || envs.include?(environment.to_sym)
-      end
-
-      # Use the specified Rack middleware
-      def use(middleware, *args, &block)
-        @prototype = nil
-        @middleware << [middleware, args, block]
-      end
-
-      def quit!(server, handler_name)
-        # Use Thin's hard #stop! if available, otherwise just #stop.
-        server.respond_to?(:stop!) ? server.stop! : server.stop
-        $stderr.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, 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 = {})
-        set options
-        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}"
-          end
-          [:INT, :TERM].each { |sig| trap(sig) { quit!(server, handler_name) } }
-          server.threaded = settings.threaded if server.respond_to? :threaded=
-          set :running, true
-          yield server if block_given?
-        end
-      rescue Errno::EADDRINUSE
-        $stderr.puts "== Someone is already performing on port #{port}!"
-      end
-
-      # The prototype instance used to process requests.
-      def prototype
-        @prototype ||= new
-      end
-
-      # Create a new instance without middleware in front of it.
-      alias new! new unless method_defined? :new!
-
-      # Create a new instance of the class fronted by its middleware
-      # 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)
-        instance = new!(*args, &bk)
-        Wrapper.new(build(instance).to_app, instance)
-      end
-
-      # Creates a Rack::Builder instance with all the middleware set up and
-      # the given +app+ as end point.
-      def build(app)
-        builder = Rack::Builder.new
-        setup_default_middleware builder
-        setup_middleware builder
-        builder.run app
-        builder
-      end
-
-      def call(env)
-        synchronize { prototype.call(env) }
-      end
-
-    private
       def setup_default_middleware(builder)
         builder.use ExtendedRack
         builder.use ShowExceptions       if show_exceptions?
@@ -1694,37 +1727,6 @@ module Sinatra
         end
       end
 
-    public
-      CALLERS_TO_IGNORE = [ # :nodoc:
-        /\/sinatra(\/(base|main|showexceptions))?\.rb$/,    # all sinatra code
-        /lib\/tilt.*\.rb$/,                                 # all tilt code
-        /^\(.*\)$/,                                         # generated code
-        /rubygems\/(custom|core_ext\/kernel)_require\.rb$/, # rubygems require hacks
-        /active_support/,                                   # active_support require hacks
-        /bundler(\/runtime)?\.rb/,                          # bundler require hacks
-        /<internal:/,                                       # internal in ruby >= 1.9.2
-        /src\/kernel\/bootstrap\/[A-Z]/                     # maglev kernel files
-      ]
-
-      # contrary to what the comment said previously, rubinius never supported this
-      if defined?(RUBY_IGNORE_CALLERS)
-        warn "RUBY_IGNORE_CALLERS is deprecated and will no longer be supported by Sinatra 2.0"
-        CALLERS_TO_IGNORE.concat(RUBY_IGNORE_CALLERS)
-      end
-
-      # Like Kernel#caller but excluding certain magic entries and without
-      # line / method information; the resulting array contains filenames only.
-      def caller_files
-        cleaned_caller(1).flatten
-      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
-        cleaned_caller 2
-      end
-
-    private
       # used for deprecation warnings
       def warn(message)
         super message + "\n\tfrom #{cleaned_caller.first.join(':')}"
@@ -1795,7 +1797,7 @@ module Sinatra
     set :running, false                   # is the built-in server running now?
     set :server, %w[HTTP webrick]
     set :bind, Proc.new { development? ? 'localhost' : '0.0.0.0' }
-    set :port, Integer(ENV['PORT'] || 4567)
+    set :port, Integer(ENV['PORT'] && !ENV['PORT'].empty? ? ENV['PORT'] : 4567)
 
     ruby_engine = defined?(RUBY_ENGINE) && RUBY_ENGINE