root/lib/vintage/handler.rb

require 'rubygems'
require 'mongrel'
require 'erubis'
require 'erb'

require 'mime/types'

require 'vintage/renderer'
require 'vintage/request_context'
require 'vintage/errors'

module Vintage
  # The Mongrel HTTP Handler.  Handles all operations with requests.
  class Handler   
    def initialize(options)
      # Make our configuration options avialable to the handler
      @options = options
      
      # Setup a DirHandler for sending static files securely
      @static_handler = Rack::File.new(@options[:static_path])
      
      # Inject our helpers in the RequestContext class to make them
      # available on each request.
      include_helpers
    end
  
    # Main request handler for Mongrel.
    def call(env)
      # Setup up the request's context (response and request information)
      request = Rack::Request.new(env)
      context = RequestContext.new(request)

      # Setup our request's path
      @request_path = request.path_info
    
      # Initialize the buffered log entry
      log_entry = ""
      log_entry << "*** request for [#{request.url}] from [#{env['REMOTE_ADDR']}]\n"

      # If it's a root request, we want to render the template we configured
      @request_path = @options[:root] if @request_path == '/'
      
      # If it's a static file we don't need to append a file extension
      filename = (@request_path =~ /\.(.*)$/) ? "#{@options[:static_path]}/#{@request_path}" : "#{@options[:path]}/#{@request_path}.#{@options[:templates]}"
      
      # Does the file exist...?
      if File.exists?(filename)
        # It's found!  Let's add to our log entry...
        log_entry << "    response: [200]\n"
        log_entry << "    rendering [#{@request_path}]\n"

        # Is it a static file?
        if (@request_path =~ /\.(.*)$/)
          # Yes?  Let our static handler take it away!
          @static_handler.call(env)
        else
          # No!  Render a template...
          content = Renderer.send(@options[:templates].to_sym, File.open("#{@options[:path]}#{@request_path}.#{@options[:templates]}", "r").read, context)
        
          # Set the content type if we're responding with a render
          context.response.headers["Content-Type"] = "text/html" if context.response.code == 200
          response = Rack::Response.new(content, context.response.code, {}.merge!(context.response.headers))
        
          # Render (if response is 200) or redirect 
          # Set cookies        
          if context.response.cookies != {}
            context.response.cookies.each do |key, value|
              response.set_cookie(key, value)
            end
          end
          
          response.finish
        end
      else
        # Page not found
        # Log the 404
        log_entry << "    response: [404]\n"
        log_entry << "    rendering 'page not found'\n"
        
        # Send back the default or a custom template
        content = @options[:errors] && @options[:errors][:not_found] ? Renderer.send(@options[:templates].to_sym, File.open("#{@options[:path]}#{@options[:errors][:not_found]}.#{@options[:templates]}", "r").read, context) : ErrorReporter.not_found(@request_path, request.params['REMOTE_ADDR'], @params)
        [context.response.code, {}.merge!(context.response.headers), content]
      end
    rescue StandardError => err
      # OOPS!  Something broke.
      context.response.code = 500

      # Log it and send an error page...
      log_entry << "\t!!! [500] #{err}\n"
      content = @options[:errors] && @options[:errors][:internal_error] ? Renderer.send(@options[:templates].to_sym, File.open("#{@options[:path]}#{@options[:errors][:internal_error]}.#{@options[:templates]}", "r").read, context) : ErrorReporter.internal_error(err, @params)
      [context.response.code, {}.merge!(context.response.headers), content]
    ensure
      # After every request push the buffered log entry out to the logger
      Log.enter log_entry.to_s + "\n"
    end
    
    # Inject the default helpers and helpers from the 
    # +helpers/+ directory (if available) into the 
    # RequestContext class.
    def include_helpers
      RequestContext.send(:include, Vintage::Helpers)
    end
  end
end