Dir[File.dirname(__FILE__) + "/../vendor/*"].each do |l|
  $:.unshift "#{File.expand_path(l)}/lib"
end
 
require 'rack'
 
require 'rubygems'
require 'time'
require 'ostruct'
require "uri"
 
if ENV['SWIFT']
 require 'swiftcore/swiftiplied_mongrel'
 puts "Using Swiftiplied Mongrel"
elsif ENV['EVENT']
  require 'swiftcore/evented_mongrel' 
  puts "Using Evented Mongrel"
end
 
class Class
  def dslify_writer(*syms)
    syms.each do |sym|
      class_eval <<-end_eval
        def #{sym}(v=nil)
          self.send "#{sym}=", v if v
          v
        end
      end_eval
    end
  end
end
 
module Rack #:nodoc:
  
  class Request #:nodoc:
 
    # Set of request method names allowed via the _method parameter hack. By default,
    # all request methods defined in RFC2616 are included, with the exception of
    # TRACE and CONNECT.
    POST_TUNNEL_METHODS_ALLOWED = %w( PUT DELETE OPTIONS HEAD )
 
    # Return the HTTP request method with support for method tunneling using the POST
    # _method parameter hack.  If the real request method is POST and a _method param is
    # given and the value is one defined in +POST_TUNNEL_METHODS_ALLOWED+, return the value
    # of the _method param instead.
    def request_method
      if post_tunnel_method_hack?
        params['_method'].upcase
      else
        @env['REQUEST_METHOD']
      end
    end
 
    def user_agent
      @env['HTTP_USER_AGENT']
    end
 
    private
 
      # Return truthfully if and only if the following conditions are met: 1.) the
      # *actual* request method is POST, 2.) the request content-type is one of
      # 'application/x-www-form-urlencoded' or 'multipart/form-data', 3.) there is a 
      # "_method" parameter in the POST body (not in the query string), and 4.) the 
      # method parameter is one of the verbs listed in the POST_TUNNEL_METHODS_ALLOWED
      # list.
      def post_tunnel_method_hack?
        @env['REQUEST_METHOD'] == 'POST' &&
          POST_TUNNEL_METHODS_ALLOWED.include?(self.POST.fetch('_method', '').upcase)
      end
 
  end
  
  module Utils
    extend self
  end
 
end
 
module Sinatra
  extend self
 
  module Version
    MAJOR = '0'
    MINOR = '2'
    REVISION = '1'
    def self.combined
      [MAJOR, MINOR, REVISION].join('.')
    end
  end
 
  class NotFound < RuntimeError; end
  class ServerError < RuntimeError; end
 
  Result = Struct.new(:block, :params, :status) unless defined?(Result)
 
  def options
    application.options
  end
  
  def application
    unless @app 
      @app = Application.new
      Sinatra::Environment.setup!
    end
    @app
  end
  
  def application=(app)
    @app = app
  end
  
  def port
    application.options.port
  end
  
  def env
    application.options.env
  end
  
  def build_application
    app = application
    app = Rack::Session::Cookie.new(app) if Sinatra.options.sessions == true
    app = Rack::CommonLogger.new(app) if Sinatra.options.logging == true
    app
  end
  
  def server
    @server ||= case options.server
    when "mongrel"
      Rack::Handler::Mongrel
    when "webrick"
      Rack::Handler::WEBrick
    when "cgi"
      Rack::Handler::CGI
    when "fastcgi"
      Rack::Handler::FastCGI
    else
      if defined?(Rack::Handler::Thin)
        Rack::Handler::Thin
      else
        options.server ||= "mongrel"
        eval("Rack::Handler::#{options.server.capitalize}")
      end
    end
  end
  
  def run
    
    begin
      puts "== Sinatra has taken the stage on port #{port} for #{env} with backup by #{server.name}"
      require 'pp'
      server.run(build_application, :Port => port) do |server|
        trap(:INT) do
          server.stop
          puts "\n== Sinatra has ended his set (crowd applauds)"
        end
      end
    rescue Errno::EADDRINUSE => e
      puts "== Someone is already performing on port #{port}!"
    end
    
  end
      
  class Event
 
    URI_CHAR = '[^/?:,&#\.]'.freeze unless defined?(URI_CHAR)
    PARAM = /(:(#{URI_CHAR}+)|\*)/.freeze unless defined?(PARAM)
    SPLAT = /(.*?)/
    attr_reader :path, :block, :param_keys, :pattern, :options
    
    def initialize(path, options = {}, &b)
      @path = URI.encode(path)
      @block = b
      @param_keys = []
      @options = options
      splats = 0
      regex = @path.to_s.gsub(PARAM) do |match|
        if match == "*"
          @param_keys << "_splat_#{splats}"
          splats += 1
          SPLAT.to_s
        else
          @param_keys << $2
          "(#{URI_CHAR}+)"
        end
      end
 
      @pattern = /^#{regex}$/
    end
        
    def invoke(request)
      params = {}
      if agent = options[:agent] 
        return unless request.user_agent =~ agent
        params[:agent] = $~[1..-1]
      end
      if host = options[:host] 
        return unless host === request.host
      end
      return unless pattern =~ request.path_info.squeeze('/')
      params.merge!(param_keys.zip($~.captures.map(&:from_param)).to_hash)
      splats = params.select { |k, v| k =~ /^_splat_\d+$/ }.sort.map(&:last)
      unless splats.empty?
        params.delete_if { |k, v| k =~ /^_splat_\d+$/ }
        params["splat"] = splats
      end
      Result.new(block, params, 200)
    end
    
  end
  
  class Error
    
    attr_reader :code, :block
    
    def initialize(code, &b)
      @code, @block = code, b
    end
    
    def invoke(request)
      Result.new(block, {}, 404)
    end
    
  end
  
  class Static
            
    def invoke(request)
      return unless File.file?(
        Sinatra.application.options.public + request.path_info.http_unescape
      )
      Result.new(block, {}, 200)
    end
    
    def block
      Proc.new do
        send_file Sinatra.application.options.public + request.path_info.http_unescape,
          :disposition => nil
      end
    end
    
  end
  
  # Adapted from actionpack
  # Methods for sending files and streams to the browser instead of rendering.
  module Streaming
    DEFAULT_SEND_FILE_OPTIONS = {
      :type         => 'application/octet-stream'.freeze,
      :disposition  => 'attachment'.freeze,
      :stream       => true, 
      :buffer_size  => 4096
    }.freeze
 
    class MissingFile < RuntimeError; end
 
    class FileStreamer
      
      attr_reader :path, :options
      
      def initialize(path, options)
        @path, @options = path, options
      end
      
      def to_result(cx, *args)
        self
      end
      
      def each
        File.open(path, 'rb') do |file|
          while buf = file.read(options[:buffer_size])
            yield buf
          end
        end
      end
      
    end
 
    protected
      # Sends the file by streaming it 4096 bytes at a time. This way the
      # whole file doesn't need to be read into memory at once.  This makes
      # it feasible to send even large files.
      #
      # Be careful to sanitize the path parameter if it coming from a web
      # page.  send_file(params[:path]) allows a malicious user to
      # download any file on your server.
      #
      # Options:
      # * <tt>:filename</tt> - suggests a filename for the browser to use.
      #   Defaults to File.basename(path).
      # * <tt>:type</tt> - specifies an HTTP content type.
      #   Defaults to 'application/octet-stream'.
      # * <tt>:disposition</tt> - specifies whether the file will be shown inline or downloaded.  
      #   Valid values are 'inline' and 'attachment' (default). When set to nil, the
      #   Content-Disposition and Content-Transfer-Encoding headers are omitted entirely.
      # * <tt>:stream</tt> - whether to send the file to the user agent as it is read (true)
      #   or to read the entire file before sending (false). Defaults to true.
      # * <tt>:buffer_size</tt> - specifies size (in bytes) of the buffer used to stream the file.
      #   Defaults to 4096.
      # * <tt>:status</tt> - specifies the status code to send with the response. Defaults to '200 OK'.
      # * <tt>:last_modified</tt> - an optional RFC 2616 formatted date value (See Time#httpdate)
      #   indicating the last modified time of the file. If the request includes an
      #   If-Modified-Since header that matches this value exactly, a 304 Not Modified response
      #   is sent instead of the file. Defaults to the file's last modified
      #   time.
      #
      # The default Content-Type and Content-Disposition headers are
      # set to download arbitrary binary files in as many browsers as
      # possible.  IE versions 4, 5, 5.5, and 6 are all known to have
      # a variety of quirks (especially when downloading over SSL).
      #
      # Simple download:
      #   send_file '/path/to.zip'
      #
      # Show a JPEG in the browser:
      #   send_file '/path/to.jpeg', :type => 'image/jpeg', :disposition => 'inline'
      #
      # Show a 404 page in the browser:
      #   send_file '/path/to/404.html, :type => 'text/html; charset=utf-8', :status => 404
      #
      # Read about the other Content-* HTTP headers if you'd like to
      # provide the user with more information (such as Content-Description).
      # http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.11
      #
      # Also be aware that the document may be cached by proxies and browsers.
      # The Pragma and Cache-Control headers declare how the file may be cached
      # by intermediaries.  They default to require clients to validate with
      # the server before releasing cached responses.  See
      # http://www.mnot.net/cache_docs/ for an overview of web caching and
      # http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.9
      # for the Cache-Control header spec.
      def send_file(path, options = {}) #:doc:
        raise MissingFile, "Cannot read file #{path}" unless File.file?(path) and File.readable?(path)
 
        options[:length]   ||= File.size(path)
        options[:filename] ||= File.basename(path)
        options[:type] ||= Rack::File::MIME_TYPES[File.extname(options[:filename])[1..-1]] || 'text/plain'
        options[:last_modified] ||= File.mtime(path).httpdate
        send_file_headers! options
 
        if options[:stream]
          throw :halt, [options[:status] || 200, FileStreamer.new(path, options)]
        else
          File.open(path, 'rb') { |file| throw :halt, [options[:status] || 200, file.read] }
        end
      end
 
      # Send binary data to the user as a file download.  May set content type, apparent file name,
      # and specify whether to show data inline or download as an attachment.
      #
      # Options:
      # * <tt>:filename</tt> - Suggests a filename for the browser to use.
      # * <tt>:type</tt> - specifies an HTTP content type.
      #   Defaults to 'application/octet-stream'.
      # * <tt>:disposition</tt> - specifies whether the file will be shown inline or downloaded.  
      #   Valid values are 'inline' and 'attachment' (default).
      # * <tt>:status</tt> - specifies the status code to send with the response. Defaults to '200 OK'.
      # * <tt>:last_modified</tt> - an optional RFC 2616 formatted date value (See Time#httpdate)
      #   indicating the last modified time of the response entity. If the request includes an
      #   If-Modified-Since header that matches this value exactly, a 304 Not Modified response
      #   is sent instead of the data.
      #
      # Generic data download:
      #   send_data buffer
      #
      # Download a dynamically-generated tarball:
      #   send_data generate_tgz('dir'), :filename => 'dir.tgz'
      #
      # Display an image Active Record in the browser:
      #   send_data image.data, :type => image.content_type, :disposition => 'inline'
      #
      # See +send_file+ for more information on HTTP Content-* headers and caching.
      def send_data(data, options = {}) #:doc:
        send_file_headers! options.merge(:length => data.size)
        throw :halt, [options[:status] || 200, data]
      end
 
    private
      def send_file_headers!(options)
        options = DEFAULT_SEND_FILE_OPTIONS.merge(options)
        [:length, :type, :disposition].each do |arg|
          raise ArgumentError, ":#{arg} option required" unless options.key?(arg)
        end
 
        # Send a "304 Not Modified" if the last_modified option is provided and matches
        # the If-Modified-Since request header value.
        if last_modified = options[:last_modified]
          header 'Last-Modified' => last_modified
          throw :halt, [ 304, '' ] if last_modified == request.env['HTTP_IF_MODIFIED_SINCE']
        end
 
        headers(
          'Content-Length'            => options[:length].to_s,
          'Content-Type'              => options[:type].strip  # fixes a problem with extra '\r' with some browsers
        )
 
        # Omit Content-Disposition and Content-Transfer-Encoding headers if
        # the :disposition option set to nil.
        if !options[:disposition].nil?
      &