codebutler 0.0.3 → 0.1.0

data/Manifest

@@ -1,6 +1,5 @@
 bin/codebutler
-lib/codebutler/sinatra.rb
 lib/codebutler.rb
 LICENCE
-Manifest
 README
+Manifest

data/codebutler.gemspec

@@ -1,33 +1,32 @@
 
-# Gem::Specification for Codebutler-0.0.3
+# Gem::Specification for Codebutler-0.1.0
 # Originally generated by Echoe
 
 Gem::Specification.new do |s|
   s.name = %q{codebutler}
-  s.version = "0.0.3"
+  s.version = "0.1.0"
 
   s.specification_version = 2 if s.respond_to? :specification_version=
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Markus Prinz"]
-  s.date = %q{2008-04-04}
+  s.date = %q{2008-04-12}
   s.default_executable = %q{codebutler}
   s.description = %q{Simply run codebutler in a directory of your choice, and it will serve all the code files it supports on a local webserver, hilighted.}
   s.email = %q{markus.prinz@qsig.org}
   s.executables = ["codebutler"]
-  s.extra_rdoc_files = ["bin/codebutler", "lib/codebutler/sinatra.rb", "lib/codebutler.rb", "README"]
-  s.files = ["bin/codebutler", "lib/codebutler/sinatra.rb", "lib/codebutler.rb", "LICENCE", "Manifest", "README", "codebutler.gemspec"]
+  s.extra_rdoc_files = ["bin/codebutler", "lib/codebutler.rb", "README"]
+  s.files = ["bin/codebutler", "lib/codebutler.rb", "LICENCE", "README", "Manifest", "codebutler.gemspec"]
   s.has_rdoc = true
   s.homepage = %q{http://codebutler.rubyforge.org}
   s.rdoc_options = ["--line-numbers", "--inline-source", "--title", "Codebutler", "--main", "README"]
   s.require_paths = ["lib"]
   s.rubyforge_project = %q{codebutler}
-  s.rubygems_version = %q{1.1.0}
+  s.rubygems_version = %q{1.1.1}
   s.summary = %q{Easily serve your highlighted codefiles from a local webserver}
 
   s.add_dependency(%q<coderay>, [">= 0.7.4"])
-  s.add_dependency(%q<mongrel>, [">= 1.0.1"])
-  s.add_dependency(%q<rack>, [">= 0.2.0"])
+  s.add_dependency(%q<sinatra>, [">= 0.2.0"])
 end
 
 
@@ -43,7 +42,7 @@ end
 #   p.summary = "Easily serve your highlighted codefiles from a local webserver"
 #   p.description = "Simply run codebutler in a directory of your choice, and it will serve all the code files it supports on a local webserver, hilighted."
 #   p.url = "http://codebutler.rubyforge.org"
-#   p.version = '0.0.3'
-#   p.dependencies = ["coderay >=0.7.4", "mongrel >=1.0.1", "rack >=0.2.0"]
+#   p.version = '0.1.0'
+#   p.dependencies = ["coderay >=0.7.4", "sinatra >=0.2.0"]
 # end
 # 

data/lib/codebutler.rb

@@ -1,10 +1,8 @@
-require 'find'
+require 'sinatra'
 require 'coderay'
+require 'find'
 require 'uri'
 
-# We bring our own version of sinatra since it's not available as a gem yet
-require 'codebutler/sinatra'
-
 module CodeButler
   
   SUPPORTED_LANGUAGES = {

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: codebutler
 version: !ruby/object:Gem::Version 
-  version: 0.0.3
+  version: 0.1.0
 platform: ruby
 authors: 
 - Markus Prinz
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-04-04 00:00:00 +02:00
+date: 2008-04-12 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -22,16 +22,7 @@ dependencies:
         version: 0.7.4
     version: 
 - !ruby/object:Gem::Dependency 
-  name: mongrel
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: 1.0.1
-    version: 
-- !ruby/object:Gem::Dependency 
-  name: rack
+  name: sinatra
   version_requirement: 
   version_requirements: !ruby/object:Gem::Requirement 
     requirements: 
@@ -47,16 +38,14 @@ extensions: []
 
 extra_rdoc_files: 
 - bin/codebutler
-- lib/codebutler/sinatra.rb
 - lib/codebutler.rb
 - README
 files: 
 - bin/codebutler
-- lib/codebutler/sinatra.rb
 - lib/codebutler.rb
 - LICENCE
-- Manifest
 - README
+- Manifest
 - codebutler.gemspec
 has_rdoc: true
 homepage: http://codebutler.rubyforge.org
@@ -85,7 +74,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: codebutler
-rubygems_version: 1.1.0
+rubygems_version: 1.1.1
 signing_key: 
 specification_version: 2
 summary: Easily serve your highlighted codefiles from a local webserver

data/lib/codebutler/sinatra.rb

@@ -1,1060 +0,0 @@
-require 'rubygems'
-require 'metaid'
-require 'uri'
-require 'thread'
-require 'time'
-
-if ENV['SWIFT']
- require 'swiftcore/swiftiplied_mongrel'
- puts "Using Swiftiplied Mongrel"
-elsif ENV['EVENT']
-  require 'swiftcore/evented_mongrel' 
-  puts "Using Evented Mongrel"
-end
-
-require 'rack'
-require 'ostruct'
-
-class Class
-  def dslify_writter(*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 = '0'
-    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
-    Rack::CommonLogger.new(application)
-  end
-  
-  def run
-    
-    begin
-      puts "== Sinatra has taken the stage on port #{port} for #{env}"
-      require 'pp'
-      Rack::Handler::Mongrel.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 = path
-      @block = b
-      @param_keys = []
-      @options = options
-      regex = @path.to_s.gsub(PARAM) do
-        @param_keys << $1
-        "(#{URI_CHAR}+)"
-      end
-      
-      regex.gsub!('*', SPLAT.to_s)
-      
-      @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)
-      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
-      )
-      Result.new(block, {}, 200)
-    end
-    
-    def block
-      Proc.new do
-        send_file Sinatra.application.options.public + request.path_info,
-          :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?
-          disposition = options[:disposition].dup || 'attachment'
-          disposition <<= %(; filename="#{options[:filename]}") if options[:filename]
-          headers 'Content-Disposition' => disposition, 'Content-Transfer-Encoding' => 'binary'
-        end
-
-        # Fix a problem with IE 6.0 on opening downloaded files:
-        # If Cache-Control: no-cache is set (which Rails does by default), 
-        # IE removes the file it just downloaded from its cache immediately 
-        # after it displays the "open/save" dialog, which means that if you 
-        # hit "open" the file isn't there anymore when the application that 
-        # is called for handling the download is run, so let's workaround that
-        header('Cache-Control' => 'private') if headers['Cache-Control'] == 'no-cache'
-      end
-  end
-  
-  module ResponseHelpers
-
-    def redirect(path, *args)
-      status(302)
-      headers 'Location' => path
-      throw :halt, *args
-    end
-    
-    def headers(header = nil)
-      @response.headers.merge!(header) if header
-      @response.headers
-    end
-    alias :header :headers
-
-  end
-  
-  module RenderingHelpers
-
-    def render(renderer, template, options={})
-      m = method("render_#{renderer}")
-      result = m.call(resolve_template(renderer, template, options), options)
-      if layout = determine_layout(renderer, template, options)
-        result = m.call(resolve_template(renderer, layout, options), options) { result }
-      end
-      result
-    end
-    
-    def determine_layout(renderer, template, options)
-      return if options[:layout] == false
-      layout_from_options = options[:layout] || :layout
-      resolve_template(renderer, layout_from_options, options, false)
-    end
-
-    private
-        
-      def resolve_template(renderer, template, options, scream = true)
-        case template
-        when String
-          template
-        when Proc
-          template.call
-        when Symbol
-          if proc = templates[template]
-            resolve_template(renderer, proc, options, scream)
-          else
-            read_template_file(renderer, template, options, scream)
-          end
-        else
-          nil
-        end
-      end
-      
-      def read_template_file(renderer, template, options, scream = true)
-        path = File.join(
-          options[:views_directory] || Sinatra.application.options.views,
-          "#{template}.#{renderer}"
-        )
-        unless File.exists?(path)
-          raise Errno::ENOENT.new(path) if scream
-          nil
-        else  
-          File.read(path)
-        end
-      end
-      
-      def templates
-        Sinatra.application.templates
-      end
-    
-  end
-
-  module Erb
-    
-    def erb(content, options={})
-      require 'erb'
-      render(:erb, content, options)
-    end
-    
-    private 
-    
-      def render_erb(content, options = {})
-        ::ERB.new(content).result(binding)
-      end
-      
-  end
-
-  module Haml
-    
-    def haml(content, options={})
-      require 'haml'
-      render(:haml, content, options)
-    end
-    
-    private
-    
-      def render_haml(content, options = {}, &b)
-        ::Haml::Engine.new(content).render(options[:scope] || self, options[:locals] || {}, &b)
-      end
-        
-  end
-
-  # Generating conservative XML content using Builder templates.
-  #
-  # Builder templates can be inline by passing a block to the builder method, or in
-  # external files with +.builder+ extension by passing the name of the template
-  # to the +builder+ method as a Symbol.
-  #
-  # === Inline Rendering
-  #
-  # If the builder method is given a block, the block is called directly with an 
-  # +XmlMarkup+ instance and the result is returned as String:
-  #   get '/who.xml' do
-  #     builder do |xml|
-  #       xml.instruct!
-  #       xml.person do
-  #         xml.name "Francis Albert Sinatra", 
-  #           :aka => "Frank Sinatra"
-  #         xml.email 'frank@capitolrecords.com'
-  #       end
-  #     end
-  #   end
-  #
-  # Yields the following XML:
-  #   <?xml version='1.0' encoding='UTF-8'?>
-  #   <person>
-  #     <name aka='Frank Sinatra'>Francis Albert Sinatra</name>
-  #     <email>Frank Sinatra</email>
-  #   </person>
-  #
-  # === Builder Template Files
-  #
-  # Builder templates can be stored in separate files with a +.builder+ 
-  # extension under the view path. An +XmlMarkup+ object named +xml+ is automatically
-  # made available to template.
-  #
-  # Example:
-  #   get '/bio.xml' do
-  #     builder :bio
-  #   end
-  #
-  # The "views/bio.builder" file might contain the following:
-  #   xml.instruct! :xml, :version => '1.1'
-  #   xml.person do
-  #     xml.name "Francis Albert Sinatra"
-  #     xml.aka "Frank Sinatra"
-  #     xml.aka "Ol' Blue Eyes"
-  #     xml.aka "The Chairman of the Board"
-  #     xml.born 'date' => '1915-12-12' do
-  #       xml.text! "Hoboken, New Jersey, U.S.A."
-  #     end
-  #     xml.died 'age' => 82
-  #   end
-  #
-  # And yields the following output:
-  #   <?xml version='1.1' encoding='UTF-8'?>
-  #   <person>
-  #     <name>Francis Albert Sinatra</name>
-  #     <aka>Frank Sinatra</aka>
-  #     <aka>Ol&apos; Blue Eyes</aka>
-  #     <aka>The Chairman of the Board</aka>
-  #     <born date='1915-12-12'>Hoboken, New Jersey, U.S.A.</born>
-  #     <died age='82' />
-  #   </person>
-  #
-  # NOTE: Builder must be installed or a LoadError will be raised the first time an
-  # attempt is made to render a builder template.
-  #
-  # See http://builder.rubyforge.org/ for comprehensive documentation on Builder.
-  module Builder
-
-    def builder(content=nil, options={}, &block)
-      options, content = content, nil if content.is_a?(Hash)
-      content = Proc.new { block } if content.nil?
-      render(:builder, content, options)
-    end
-
-    private
-
-      def render_builder(content, options = {}, &b)
-        require 'builder'
-        xml = ::Builder::XmlMarkup.new(:indent => 2)
-        case content
-        when String
-          eval(content, binding, '<BUILDER>', 1)
-        when Proc
-          content.call(xml)
-        end
-        xml.target!
-      end
-
-  end
-
-  class EventContext
-    
-    include ResponseHelpers
-    include Streaming
-    include RenderingHelpers
-    include Erb
-    include Haml
-    include Builder
-    
-    attr_accessor :request, :response
-    
-    dslify_writter :status, :body
-    
-    def initialize(request, response, route_params)
-      @request = request
-      @response = response
-      @route_params = route_params
-      @response.body = nil
-    end
-    
-    def params
-      @params = @route_params.merge(@request.params)
-    end
-        
-    def stop(*args)
-      throw :halt, args
-    end
-    
-    def complete(returned)
-      @response.body || returned
-    end
-    
-    private
-
-      def method_missing(name, *args, &b)
-        @response.send(name, *args, &b)
-      end
-    
-  end
-  
-  class Application
-    
-    attr_reader :events, :errors, :templates, :filters
-    attr_reader :clearables, :reloading
-    
-    attr_writer :options
-    
-    def self.default_options
-      @@default_options ||= {
-        :run => true,
-        :port => 4567,
-        :env => :development,
-        :root => Dir.pwd,
-        :views => Dir.pwd + '/views',
-        :public => Dir.pwd + '/public'
-      }
-    end
-    
-    def default_options
-      self.class.default_options
-    end
-
-    
-    ##
-    # Load all options given on the command line
-    # NOTE:  Ignores --name so unit/spec tests can run individually
-    def load_options!
-      require 'optparse'
-      OptionParser.new do |op|
-        op.on('-p port') { |port| default_options[:port] = port }
-        op.on('-e env') { |env| default_options[:env] = env }
-        op.on('-x') { |env| default_options[:mutex] = true }
-      end.parse!(ARGV.dup.select { |o| o !~ /--name/ })
-    end
-
-    # Called immediately after the application is initialized or reloaded to
-    # register default events. Events added here have dibs on requests since
-    # they appear first in the list.
-    def load_default_events!
-      events[:get] << Static.new
-    end
-
-    def initialize
-      @clearables = [
-        @events = Hash.new { |hash, key| hash[key] = [] },
-        @errors = Hash.new,
-        @filters = Hash.new { |hash, key| hash[key] = [] },
-        @templates = Hash.new
-      ]
-      load_options!
-      load_default_events!
-    end
-
-    def define_event(method, path, options = {}, &b)
-      events[method] << event = Event.new(path, options, &b)
-      event
-    end
-    
-    def define_template(name=:layout, &b)
-      templates[name] = b
-    end
-    
-    def define_error(code, options = {}, &b)
-      errors[code] = Error.new(code, &b)
-    end
-    
-    def define_filter(type, &b)
-      filters[:before] << b
-    end
-
-    # Visits and invokes each handler registered for the +request_method+ in
-    # definition order until a Result response is produced. If no handler
-    # responds with a Result, the NotFound error handler is invoked.
-    #
-    # When the request_method is "HEAD" and no valid Result is produced by
-    # the set of handlers registered for HEAD requests, an attempt is made to
-    # invoke the GET handlers to generate the response before resorting to the
-    # default error handler.
-    def lookup(request)
-      method = request.request_method.downcase.to_sym
-      events[method].eject(&[:invoke, request]) ||
-        (events[:get].eject(&[:invoke, request]) if method == :head) ||
-        errors[NotFound].invoke(request)
-    end
-
-    def options
-      @options ||= OpenStruct.new(default_options)
-    end
-    
-    def development?
-      options.env == :development
-    end
-
-    def reload!
-      @reloading = true
-      clearables.each(&:clear)
-      load_default_events!
-      Kernel.load $0
-      @reloading = false
-      Environment.setup!
-    end
-    
-    def mutex
-      @@mutex ||= Mutex.new
-    end
-    
-    def run_safely
-      if options.mutex
-        mutex.synchronize { yield }
-      else
-        yield
-      end
-    end
-    
-    def call(env)
-      reload! if development?
-      request = Rack::Request.new(env)
-      result = lookup(request)
-      context = EventContext.new(
-        request, 
-        Rack::Response.new,
-        result.params
-      )
-      context.status(result.status)
-      begin
-        returned = run_safely do
-          catch(:halt) do
-            filters[:before].each { |f| context.instance_eval(&f) }
-            [:complete, context.instance_eval(&result.block)]
-          end
-        end
-        body = returned.to_result(context)
-      rescue => e
-        request.env['sinatra.error'] = e
-        context.status(500)
-        result = (errors[e.class] || errors[ServerError]).invoke(request)
-        returned = run_safely do
-          catch(:halt) do
-            [:complete, context.instance_eval(&result.block)]
-          end
-        end
-        body = returned.to_result(context)
-      end
-      body = '' unless body.respond_to?(:each)
-      body = '' if request.request_method.upcase == 'HEAD'
-      context.body = body.kind_of?(String) ? [*body] : body
-      context.finish
-    end
-    
-  end
-  
-  
-  module Environment
-    extend self
-    
-    def setup!
-      configure do
-        error do
-          raise request.env['sinatra.error'] if Sinatra.options.raise_errors
-          '<h1>Internal Server Error</h1>'
-        end
-        not_found { '<h1>Not Found</h1>'}
-      end
-      
-      configures :development do
-
-        get '/sinatra_custom_images/:image.png' do
-          File.read(File.dirname(__FILE__) + "/../images/#{params[:image]}.png")
-        end
-
-        not_found do
-          %Q(
-          <style>
-          body {
-            text-align: center; 
-            color: #888;
-            font-family: Arial; 
-            font-size: 22px; 
-            margin: 20px;
-          }
-          #content {
-            margin: 0 auto;
-            width: 500px;
-            text-align: left;
-          }
-          </style>
-          <html>
-            <body>
-              <h2>Sinatra doesn't know this diddy.</h2>
-              <img src='/sinatra_custom_images/404.png'></img>
-              <div id="content">
-                Try this:
-<pre>#{request.request_method.downcase} "#{request.path_info}" do
-  .. do something ..
-end<pre>
-              </div>
-            </body>
-          </html>
-          )
-        end
-
-        error do
-          @error = request.env['sinatra.error']
-          %Q(
-          <html>
-          	<body>
-          		<style type="text/css" media="screen">
-          			body {
-          				font-family: Verdana;
-          				color: #333;
-          			}
-
-          			#content {
-          				width: 700px;
-          				margin-left: 20px;
-          			}
-
-          			#content h1 {
-          				width: 99%;
-          				color: #1D6B8D;
-          				font-weight: bold;
-          			}
-
-          			#stacktrace {
-          			  margin-top: -20px;
-          			}
-
-          			#stacktrace pre {
-          				font-size: 12px;
-          				border-left: 2px solid #ddd;
-          				padding-left: 10px;
-          			}
-
-          			#stacktrace img {
-          				margin-top: 10px;
-          			}
-          		</style>
-          		<div id="content">
-            		<img src="/sinatra_custom_images/500.png" />
-            		<div class="info">
-                  Params: <pre>#{params.inspect}
-            		</div>
-          			<div id="stacktrace">
-          				<h1>#{Rack::Utils.escape_html(@error.class.name + ' - ' + @error.message)}</h1>
-          				<pre><code>#{Rack::Utils.escape_html(@error.backtrace.join("\n"))}</code></pre>
-          		</div>
-          	</body>
-          </html>
-          )
-        end
-      end
-    end
-  end
-  
-end
-
-def get(path, options ={}, &b)
-  Sinatra.application.define_event(:get, path, options, &b)
-end
-
-def post(path, options ={}, &b)
-  Sinatra.application.define_event(:post, path, options, &b)
-end
-
-def put(path, options ={}, &b)
-  Sinatra.application.define_event(:put, path, options, &b)
-end
-
-def delete(path, options ={}, &b)
-  Sinatra.application.define_event(:delete, path, options, &b)
-end
-
-def before(&b)
-  Sinatra.application.define_filter(:before, &b)
-end
-
-def helpers(&b)
-  Sinatra::EventContext.class_eval(&b)
-end
-
-def error(type = Sinatra::ServerError, options = {}, &b)
-  Sinatra.application.define_error(type, options, &b)
-end
-
-def not_found(options = {}, &b)
-  Sinatra.application.define_error(Sinatra::NotFound, options, &b)
-end
-
-def layout(name = :layout, &b)
-  Sinatra.application.define_template(name, &b)
-end
-
-def template(name, &b)
-  Sinatra.application.define_template(name, &b)
-end
-
-def use_in_file_templates!
-  require 'stringio'
-  templates = IO.read(caller.first.split(':').first).split('__FILE__').last
-  data = StringIO.new(templates)
-  current_template = nil
-  data.each do |line|
-    if line =~ /^##\s?(.*)/
-      current_template = $1.to_sym
-      Sinatra.application.templates[current_template] = ''
-    elsif current_template
-      Sinatra.application.templates[current_template] << line
-    end
-  end
-end
-
-def configures(*envs, &b)
-  yield if  !Sinatra.application.reloading && 
-            (envs.include?(Sinatra.application.options.env) ||
-            envs.empty?)
-end
-alias :configure :configures
-
-def set_options(opts)
-  Sinatra::Application.default_options.merge!(opts)
-  Sinatra.application.options = nil
-end
-
-def mime(ext, type)
-  Rack::File::MIME_TYPES[ext.to_s] = type
-end
-
-### Misc Core Extensions
-
-module Kernel
-
-  def silence_warnings
-    old_verbose, $VERBOSE = $VERBOSE, nil
-    yield
-  ensure
-    $VERBOSE = old_verbose
-  end
-
-end
-
-class String
-
-  # Converts +self+ to an escaped URI parameter value
-  #   'Foo Bar'.to_param # => 'Foo%20Bar'
-  def to_param
-    URI.escape(self)
-  end
-  
-  # Converts +self+ from an escaped URI parameter value
-  #   'Foo%20Bar'.from_param # => 'Foo Bar'
-  def from_param
-    URI.unescape(self)
-  end
-  
-end
-
-class Hash
-  
-  def to_params
-    map { |k,v| "#{k}=#{URI.escape(v)}" }.join('&')
-  end
-  
-  def symbolize_keys
-    self.inject({}) { |h,(k,v)| h[k.to_sym] = v; h }
-  end
-  
-  def pass(*keys)
-    reject { |k,v| !keys.include?(k) }
-  end
-  
-end
-
-class Symbol
-  
-  def to_proc 
-    Proc.new { |*args| args.shift.__send__(self, *args) }
-  end
-  
-end
-
-class Array
-  
-  def to_hash
-    self.inject({}) { |h, (k, v)|  h[k] = v; h }
-  end
-  
-  def to_proc
-    Proc.new { |*args| args.shift.__send__(self[0], *(args + self[1..-1])) }
-  end
-  
-end
-
-module Enumerable
-  
-  def eject(&block)
-    find { |e| result = block[e] and break result }
-  end
-  
-end
-
-### Core Extension results for throw :halt
-
-class Proc
-  def to_result(cx, *args)
-    cx.instance_eval(&self)
-    args.shift.to_result(cx, *args)
-  end
-end
-
-class String
-  def to_result(cx, *args)
-    args.shift.to_result(cx, *args)
-    self
-  end
-end
-
-class Array
-  def to_result(cx, *args)
-    self.shift.to_result(cx, *self)
-  end
-end
-
-class Symbol
-  def to_result(cx, *args)
-    cx.send(self, *args)
-  end
-end
-
-class Fixnum
-  def to_result(cx, *args)
-    cx.status self
-    args.shift.to_result(cx, *args)
-  end
-end
-
-class NilClass
-  def to_result(cx, *args)
-    ''
-  end
-end
-
-at_exit do
-  raise $! if $!
-  if Sinatra.application.options.run
-    Sinatra.run 
-  end
-end
-
-mime :xml,  'application/xml'
-mime :js,  'application/javascript'