kiss 1.1 → 1.7

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2005-2008 MultiWidget LLC.
+Copyright (c) 2005-2010 MultiWidget LLC.
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/Rakefile

@@ -23,8 +23,9 @@ spec = Gem::Specification.new do |s|
     )
     
     s.add_dependency('rack','=0.4.0')
-    s.add_dependency('sequel','>=2.5.0')
+    s.add_dependency('sequel','>=3.0.0')
     s.add_dependency('erubis')
+    s.add_dependency('tzinfo')
 end
 
 Rake::GemPackageTask.new(spec) do |pkg|

data/VERSION

@@ -1 +1 @@
-1.1
+1.7

data/bin/kiss

@@ -1,45 +1,172 @@
 #!/usr/bin/env ruby
 
+require 'rubygems'
+require 'kiss'
+require 'optparse'
+require 'irb'
+
+def main
+  parse_options
+  Kiss::default_project_dir = $project_dir
+  
+  command = ARGV.shift
+  
+  case command
+  when 'create'
+    create
+  when 'run'
+    run
+  when 'irb'
+    kiss_irb
+  when 'set'
+    set
+  when 'evolve'
+    evolve
+  when 'help'
+    display_usage(ARGV[0])
+  else
+    display_usage
+  end
+  Kernel::exit
+end
+
+def parse_options
+  $project_dir = Dir.pwd
+  $rack_builder = []
+  
+  opts = OptionParser.new do |opt|
+    opt.program_name = File.basename $0
+    opt.version = '1'
+    opt.release = nil
+    opt.summary_indent = ' ' * 4
+    # opt.banner = <<-EOT
+    # 
+    # EOT
+  
+    opt.separator nil
+    opt.separator "Options:"
+    opt.separator nil
+
+    opt.on("--evolution=VERSION", "-e",
+           "Specifies the desired evolution number.") do |value|
+      $evolution_number = value.sub(/\A\=/,'')
+    end
+    
+    opt.on("--project=DIRECTORY", "-p",
+           "Specifies the desired application/project directory.") do |value|
+      $project_dir = value.sub(/\A\=/,'')
+    end
+    
+    opt.on("--builder=RACK_BUILDER", "-b",
+           "Specifies a desired Rack builder module name for kiss run.") do |value|
+      $rack_builder.push( *( value.sub(/\A\=/,'').split(/,/).map{|b| b.to_sym} ))
+    end
+    
+    opt.separator nil
+  
+  end
+
+  result = opts.parse! ARGV
+rescue OptionParser::InvalidArgument, OptionParser::InvalidOption => e
+  puts opts
+  puts
+  puts e
+  Kernel::exit 1
+end
 
 def create
-  project_name = ARGV[0]
-  display_usage('create') unless project_name =~ /\S/
+  archive_path = File.join(File.dirname(File.dirname(File.expand_path(__FILE__))),'data','scaffold.tgz')
 
-  path = File.join(File.dirname(File.dirname(File.expand_path(__FILE__))),'data','scaffold.tgz')
+  Dir.mkdir($project_dir) unless File.directory?($project_dir)
 
-  `mkdir #{project_name}`
+  puts "Expanding '#{archive_path}' to '#{$project_dir}'..."
+  `cd '#{$project_dir}'; tar xvfz '#{archive_path}'`
+  
+  puts 'Kiss application scaffold created.'
+end
 
-  print "Expanding '#{path}' to '#{project_name}'..."
+def load_kiss_project
+  Kiss.load
+end
 
-  `cd '#{ARGV[0]}'; tar xvfz '#{path}'`
+def set
+  app = load_kiss_project
+  db = app.database
+  
+  if $evolution_number
+    db[:evolution_number].update(:version => $evolution_number)
+    puts "Database evolution number set to #{$evolution_number}."
+  end
+end
 
-  puts 'done.'
+def evolve
+  app = load_kiss_project
+  db = app.database
+  
+  db_version = db.evolution_number
+  target_version = app.last_evolution_file_number
+  
+  target_version = $evolution_number if $evolution_number &&
+    ($evolution_number < target_version)
+  
+  while db_version < target_version
+    db_version += 1
+    
+    filename = app.evolution_file(db_version)
+    print "Applying evolution file number #{db_version}: #{filename}...\n\n"
+    
+    db.transaction do
+      File.read(filename).gsub(/\#[^\n]*/,'').split(';').each do |query|
+        next if query.blank?
+        query.sub!(/\A\s*/,'')
+        print (query + ";\n\n")
+        db << query
+      end
+    end
+    db[:evolution_number].update(:version => db_version)
+    puts "Database at evolution number #{db_version}."
+  end
 end
 
 def run
-  project_name = ARGV[0]
-  project_name = '.' unless project_name =~ /\S/
-  
-  require 'rubygems'
-  require 'kiss'
+  Kiss.run( :rack_builder => $rack_builder )
+end
 
-  Kiss.run( :project_dir => project_name )
+def kiss_irb
+  catch (:IRB_EXIT) do
+    IRB.start
+  end
 end
 
 def display_usage(command = nil)
   case command
   when 'create'
     puts <<-EOT
-usage: kiss create <app_directory>
-Creates a skeleton for a new Kiss application.
+usage: kiss create
+Creates a Kiss application scaffold.
 EOT
   when 'run'
     puts <<-EOT
-usage: kiss run [app_directory]
-Runs a Kiss application located within app_directory.
+usage: kiss run
+Runs a Kiss application.
+EOT
+  when 'irb'
+    puts <<-EOT
+usage: kiss irb
+Begin an interactive Ruby (IRB) session in the context of a
+Kiss application.
 
-The app_directory path may be omitted when running this command from 
-within the top-level directory of a Kiss application.
+Type 'app = Kiss.new' at the irb prompt to load the application.
+EOT
+  when 'set'
+    puts <<-EOT
+usage: kiss set [-options]
+Set application variables as specified in the command options.
+EOT
+  when 'evolve'
+    puts <<-EOT
+usage: kiss evolve
+Applies evolution files to database of Kiss application.
 EOT
   else
     puts <<-EOT
@@ -48,6 +175,10 @@ Utility to support and facilitate the Kiss web framework.
 
 Commands:
   create   - Create a new Kiss application project.
+  evolve   - Run database evolutions from Kiss project.
+  set      - Set application variables such as current database 
+             evolution number.
+  irb      - Start an interactive Ruby session with Kiss loaded.
   run      - Run a Kiss application.
   help     - Display usage info.
 
@@ -56,20 +187,6 @@ For help on any command above, type:
 EOT
   end
   puts
-  exit
 end
 
-
-# main
-
-case (command = ARGV.shift)
-when 'create'
-  create
-when 'run'
-  run
-when 'help'
-  display_usage(ARGV[0])
-else
-  display_usage
-end
-exit
+main

data/lib/kiss.rb

@@ -1,9 +1,9 @@
 # Kiss - A web application framework for Ruby
-# Copyright (C) 2005-2008 MultiWidget LLC.
+# Copyright (C) 2005-2010 MultiWidget LLC.
 # See LICENSE for details.
 
 # Author::    Shawn Van Ittersum, MultiWidget LLC
-# Copyright:: Copyright (c) 2005-2008 MultiWidget LLC.
+# Copyright:: Copyright (c) 2005-2010 MultiWidget LLC.
 # License::   MIT X11 License
 
 require 'rubygems'
@@ -12,688 +12,365 @@ require 'rack'
 require 'rack/request'
 require 'erubis'
 
-require 'kiss/hacks'
+# Sequel may not be required anymore for string inflectors (singular, plural, titlecase, etc.),
+# if database functionality is not used, since inflectors are now in sequel/extensions/inflector.
+require 'sequel'
+require 'sequel/extensions/inflector'
 
-require 'kiss/controller_accessors'
-require 'kiss/template_methods'
-require 'kiss/action'
-
-autoload :Sequel, 'sequel'
-
-module Rack
-  autoload :Bench, 'kiss/rack/bench'
-  autoload :ErrorsOK, 'kiss/rack/errors_ok'
-  autoload :EmailErrors, 'kiss/rack/email_errors'
-  autoload :Facebook, 'kiss/rack/facebook'
-  autoload :FileNotFound, 'kiss/rack/file_not_found'
-  autoload :LogExceptions, 'kiss/rack/log_exceptions'
-  autoload :Recorder, 'kiss/rack/recorder'
-  autoload :ShowDebug, 'kiss/rack/show_debug'
-  autoload :ShowExceptions, 'kiss/rack/show_exceptions'
-end
+require 'tzinfo'
 
-module Digest; end
-
-class Class
-  # adapted from Rails, re-written for speed (only one class_eval call)
-  def cattr_reader(*syms)
-    class_eval(
-      syms.flatten.map do |sym|
-        sym.is_a?(Hash) ? '' : %Q(
-          unless defined? @@#{sym}
-            @@#{sym} = nil
-          end
+require 'kiss/ext/core'
+require 'kiss/ext/rack'
 
-          def self.#{sym}
-            @@#{sym}
-          end
-
-          def #{sym}
-            @@#{sym}
-          end
-        
-        )
-      end.join, __FILE__, __LINE__
-    )
-  end
-end
+require 'kiss/accessors/controller'
+require 'kiss/accessors/request'
+require 'kiss/accessors/template'
+require 'kiss/action'
 
 # Kiss - An MVC web application framework for Ruby, built on:
 # * Erubis template engine
 # * Sequel database ORM library
 # * Rack web server abstraction
 class Kiss
+  autoload :Bench, 'kiss/bench'
+  autoload :Debug, 'kiss/debug'
   autoload :ExceptionReport, 'kiss/exception_report'
-  autoload :Mailer, 'kiss/mailer'
-  autoload :Iterator, 'kiss/iterator'
-  autoload :Login, 'kiss/login'
   autoload :Form, 'kiss/form'
   autoload :Format, 'kiss/format'
+  autoload :Iterator, 'kiss/iterator'
+  autoload :Login, 'kiss/login'
+  autoload :Mailer, 'kiss/mailer'
+  autoload :Request, 'kiss/request'
+  autoload :SequelDatabase, 'kiss/ext/sequel_database'
+  autoload :SequelMySQLDataset, 'kiss/ext/sequel_mysql_dataset'
   autoload :SequelSession, 'kiss/sequel_session'
   autoload :StaticFile, 'kiss/static_file'
-  autoload :Bench, 'kiss/bench'
-  autoload :Debug, 'kiss/debug'
-  
-  @@digest = {
-    :MD5 => "digest/md5",
-    :RMD160 => "digest/rmd160",
-    :SHA1 => "digest/sha1",
-    :SHA256 => "digest/sha2",
-    :SHA384 => "digest/sha2",
-    :SHA512 => "digest/sha2"
-  }
-  @@digest.each_pair do |type,path|
-    Digest.autoload type, path
+  autoload :Template, 'kiss/template'
+  
+  # Exceptions classes.
+  class FileNotFoundError < RuntimeError
+    class InvalidAction < self; end
+    class Action < self; end
+    class Template < self; end
+    class Page < self; end
+    class Object < self; end
   end
   
-  # attributes below are application-wide
-  cattr_reader :action_dir, :template_dir, :email_template_dir, :model_dir, :upload_dir,
-    :evolution_dir, :asset_dir, :public_dir, :environment, :options, :layout, :rack_file
-  
-  # attributes below are request-specific
-  attr_reader :protocol, :host, :request, :exception_cache, :env
+  # These supplement the MIME types defined by Rack.
+  MIME_TYPES = {
+    'rhtml' => 'text/html'
+  }
   
   @@default_action = 'index'
   @@default_cookie_name = 'Kiss'
+  @@default_project_dir = '.'
   
-  # these supplement the mime types from Rack::File
-  @@mime_types = {
-    'rhtml' => 'text/html'
-  }
+  cattr_accessor :default_project_dir
   
-  ### Class Methods
+  # application-wide attributes
+  _attr_reader :action_dir, :template_dir, :email_template_dir, :model_dir, :upload_dir,
+    :evolution_dir, :asset_host, :asset_uri, :asset_dir, :public_dir, :environment, 
+    :rack_file, :default_action, :exception_log_file, :session_class, :cookie_name,
+    :authenticate_all, :authenticate_exclude, :exception_handlers, :project_dir,
+    :config, :mailer_config, :mailer_override
+  
+  _attr_accessor :session_setup
   
+  # Registry of classes by file path.
+  @_classes = {}
+  
+  ### Class Methods
   class << self
-    # Creates new controller instance to handle Rack request.
-    def call(env)
-      new.call(env)
-    end
+    alias_method :load, :new
     
-    # Runs Kiss application found at project_dir (default: '..'), with options 
-    # read from config files plus additional options if passed in.
-    def run(options = nil)
-      begin
-        if @@options
-          merge_options(options) if options
-        else
-          load(options)
-        end
-      
-        app = self
-        builder_options = @@options[:rack_builder] || []
-        rack = Rack::Builder.new do
-          builder_options.each do |builder_option|
-            if builder_option.is_a?(Array)
-              builder_args = builder_option
-              builder_option = builder_args.shift
-            else
-              builder_args = []
-            end
-        
-            unless builder_option.is_a?(Class)
-              builder_option = Rack.const_get(builder_option.to_s)
-            end
-            
-            use(builder_option,*builder_args)
-          end
-          
-          run app
-        end.to_app
-        
-        handler = @@options[:rack_handler] || Rack::Handler::WEBrick
-        if !handler.is_a?(Class)
-          handler = Rack::Handler.const_get(handler.to_s)
-        end
-        handler.run(rack,@@options[:rack_handler_options] || {:Port => 4000})
-      rescue StandardError, LoadError, SyntaxError => e
-        if @@options[:rack_handler] == :CGI
-          print "Content-type: text/html\n\n"
-          print $debug_messages.to_s + Kiss::ExceptionReport.generate(e)
-        else
-          print "Content-type: text/plain\n\n"
-          puts "exception:\n" + e.message
-          puts "\ntraceback:\n" + e.backtrace.join("\n")
-        end
-      end
+    def rack(config = {})
+      self.new(config).rack
     end
     
-    # Load and set up Kiss application from config file options and
-    # any passed-in options.
-    def load(loader_options = nil)
-      # store cached files
-      @@file_cache = {}
-      @@directory_cache = {}
-      @@file_cache_time = {}
-      
-      loader_options ||= {}
-      # if loader_options is string, then it specifies environment
-      # else it should be a hash of config options
-      if loader_options.is_a?(String)
-        loader_options = { :environment => loader_options }
-      end
-    
-      # environment
-      @@environment = loader_options[:environment]
-    
-      # directories
-      script_dir = $0.sub(/[^\/]+\Z/,'')
-      script_dir = '' if script_dir == './'
-      @@project_dir = script_dir + (loader_options[:project_dir] || loader_options[:root_dir] || '..')
-      Dir.chdir(@@project_dir)
-    
-      @@config_dir = loader_options[:config_dir] || 'config'
-    
-      # get environment name from config/environment
-      if (@@environment.nil?) && File.file?(env_file = @@config_dir+'/environment')
-        @@environment = File.read(env_file).sub(/\s+\Z/,'')
-      end
-    
-      # init options
-      @@options = {
-        :layout => '/_layout'
-      }
-      @@lib_dirs = ['lib']
-      @@gem_dirs = ['gems']
-      @@require = []
-      @@authenticate_exclude = ['/login','/logout']
-    
-      # common (shared) config
-      if (File.file?(config_file = @@config_dir+'/common.yml'))
-        merge_options( YAML::load(File.read(config_file)) )
-      end
-      # environment config
-      if (File.file?(config_file = "#{@@config_dir}/environments/#{@@environment}.yml"))
-        merge_options( YAML::load(File.read(config_file)) )
-      end
-    
-      merge_options( loader_options )
-    
-      # set class vars from options
-      @@action_dir = @@options[:action_dir] || 'actions'
-      @@template_dir = @@options[:template_dir] ? @@options[:template_dir] : @@action_dir
-    
-      @@asset_dir = @@public_dir = @@options[:asset_dir] || @@options[:public_dir] || 'public_html'
-    
-      @@model_dir = @@options[:model_dir] || 'models'
-      
-      @@evolution_dir = @@options[:evolution_dir] || 'evolutions'
-    
-      @@email_template_dir = @@options[:email_template_dir] || 'email_templates'
-      @@upload_dir = @@options[:upload_dir] || 'uploads'
-      
-      @@cookie_name = @@options[:cookie_name] || @@default_cookie_name
-      @@default_action = @@options[:default_action] || @@default_action
-      @@action_root_class = @@options[:action_class] || Class.new(Kiss::Action)
-      
-      # exception log
-      @@exception_log_file = @@options[:exception_log] ? ::File.open(@@options[:exception_log],'a') : nil
-      
-      # default layout
-      @@layout = @@options[:layout]
-    
-      # app_url: URL of the app actions root
-      @@protocol = ENV['HTTPS'] == 'on' ? 'https' : 'http'
-      @@app_host = @@options[:app_host] ? (@@protocol + '://' + @@options[:app_host]) : ''
-      @@app_uri = @@options[:app_uri] || ''
-      @@app_url =  @@app_host + @@app_uri
-      
-      # asset host: hostname of static assets
-      # (remove http:// prefix if present)
-      @@asset_host = @@options[:asset_host]
-      @@asset_host.sub!(/^http:\/\//,'') if @@asset_host
-    
-      # public_uri: uri of requests to serve from public_dir
-      @@asset_uri = @@options[:asset_uri] || @@options[:public_uri] || ''
-      @@rack_file = Rack::File.new(@@asset_dir) if @@asset_uri
-    
-      # include lib dirs
-      $LOAD_PATH.unshift(*( @@lib_dirs.flatten.select {|dir| File.directory?(dir) } ))
-    
-      # add gem dir to rubygems search path
-      Gem.path.unshift(*( @@gem_dirs.flatten.select {|dir| File.directory?(dir) } ))
-    
-      # require libs
-      @@require.flatten.each {|lib| require lib }
-    
-      # session class
-      @@session_class = @@options[:session_class] ?
-        (@@session_class = (@@options[:session_class].class == Class) ?
-          @@options[:session_class] : @@options[:session_class].to_const
-        ) : nil
-    
-      # load extensions to action class
-      action_extension_path = @@action_dir + '/_action.rb'
-      if File.file?(action_extension_path)
-        @@action_root_class.class_eval(File.read(action_extension_path),action_extension_path) rescue nil
-      end
-      
-      @@action_classes = {}
-    
-      # database
-      @@database_config = @@options[:database]
-      @@database_pool = []
-    
-      self
-    end
-    
-    # Returns true if specified path is a directory.
-    # Cache result if file_cache_no_reload option is set; otherwise, always check filesystem.
-    def directory_exists?(dir)
-      @@options[:file_cache_no_reload] ? (
-        @@directory_cache.has_key?(path) ?
-          @@directory_cache[dir] :
-          @@directory_cache[dir] = File.directory?(dir)
-        ) : File.directory?(dir)
-    end
-  
-    # Merges specified options into previously defined/merged Kiss options.
-    def merge_options(config_options)
-      if config_options
-        if env_vars = config_options.delete(:ENV)
-          env_vars.each_pair {|k,v| ENV[k] = v }
-        end
-        if lib_dirs = config_options.delete(:lib_dirs)
-          @@lib_dirs.push( lib_dirs )
-        end
-        if gem_dirs = config_options.delete(:gem_dirs)
-          @@gem_dirs.push( gem_dirs )
-        end
-        if require_libs = config_options.delete(:require)
-          @@require.push( require_libs )
-        end
-        if auth_exclude = config_options.delete(:authenticate_exclude)
-          @@authenticate_exclude.push( *(auth_exclude.map { |action| action =~ /\A\// ? action : '/'+action }) )
-        end
-    
-        @@options.merge!( config_options )
-      end
+    def run(config = {})
+      self.new(config).run
     end
     
     # Converts passed-in filename to absolute path if it does not start with '/'.
     def absolute_path(filename)
-      filename = ( filename =~ /\A\// ? '' : (Dir.pwd + '/') ) + filename
-    end
-    
-    # prepend addition just inside the specified tag of document
-    def html_prepend(addition,document,tag)
-      document = document.body unless document.is_a?(String)
-      document.sub(/(\<#{tag}[^\>]*\>)/i, '\1'+addition)
-    end
-    
-    # Returns string representation of object with HTML entities escaped.
-    def html_escape(obj)
-      Rack::Utils.escape_html(
-        obj.is_a?(String) ? obj : obj.inspect
-      ).gsub(/^(\s+)/) {'&nbsp;' * $1.length}
-    end
-    
-    # Escapes string for use in URLs.
-    def url_escape(string)
-    	# encode space to '+'; don't encode letters, numbers, periods
-      string.gsub(/([^A-Za-z0-9\.])/) { sprintf("%%%02X", $&.unpack("C")[0]) }
+      ( filename[0,1] == '/' ) ? filename : "#{Dir.pwd}/#{filename}"
     end
     
     # Returns MIME type corresponding to passed-in extension.
     def mime_type(extension)
-      Rack::File::MIME_TYPES[extension] || @@mime_types[extension]
+      extension = extension.to_s
+      rack_mime_types = Rack::Mime::MIME_TYPES rescue Rack::File::MIME_TYPES
+      rack_mime_types[extension] || rack_mime_types['.' + extension] || Kiss::MIME_TYPES[extension]
     end
     
-    # Returns Digest class used to generate digest of specified type.
-    def digest_class(type)
-      type = type.to_sym
-      @@digest[type] ? Digest.const_get(type) : nil
+    # Register a class by its file path, to enable context_class to work.
+    def register_class_path(klass, path)
+      @_classes[path] = klass
     end
     
-    # Converts date strings from m/d/y to y/m/d. Useful for MySQL.
-    def mdy_to_ymd(date)
-      return '0000-00-00' unless date && date =~ /\S/
-      date.sub!(/\A\D+/,'')
-      date.sub!(/\D+\Z/,'')
-    
-      month, day, year = date.split(/\D+/,3).each {|s| s.to_i}
-    
-      return 0 unless month && day
-      
-      current_year = Time.now.year
-      if !year || year.length == 0
-        # use current year if year is missing.
-        year = current_year
-      else
-        # convert two-digit years to four-digit years
-        year = year.to_i
-        if year < 100
-          year += 1900
-          year += 100 if year < current_year - 95
-        end
-      end
-    
-      return sprintf("%04d-%02d-%02d",year,month.to_i,day.to_i)
-    end
-  
-    # Validates value against specified format.
-    # If required is true, value must contain a non-whitespace character.
-    # If required is false, value need not match format if and only if value contains only whitespace.
-    def validate_value(value, format, required = false, label = nil)
-      if required && (value !~ /\S/)
-        # value required
-        raise "#{label || 'value'} required"
-      elsif format && (value =~ /\S/)
-        format = Kiss::Format.lookup(format)
-      
-        begin
-          format.validate(value)
-        rescue Kiss::Format::ValidateError => e
-          raise e.class, "#{label} validation error: #{e.message}"
+    # Finds the class defined by the file path of the execution context.
+    def context_class
+      caller.each do |frame|
+        if klass = @_classes[frame.sub(/\:.*/, '')]
+          return klass
         end
       end
     end
-  
-    # Generates string of random text of the specified length.
-    def random_text(length)
-      chars = ('A'..'Z').to_a + ('0'..'9').to_a  # array
-  
-      text = ''
-      size = chars.size
-      length.times { text += chars[rand(size)] }
-    
-      text
-    end
-    
-    # Given a file path, caches or returns the file's contents or the return value of
-    # the passed block applied to the file's contents.
-    # If file is not found, the file's contents are nil.
-    def file_cache(path, report_change = false)
-      raise 'nil file path cannot be cached' unless path
-      
-      if @@file_cache.has_key?(path) && @@options[:file_cache_no_reload]
-        # already loaded this path, and no_reload option is on; don't re-cache
-        change = false
-      elsif !@@file_cache.has_key?(path)
-        # haven't loaded this path yet
-        change = true
-        if !File.file?(path)
-          # nil path, of file doesn't exist
-          @@file_cache_time[path] = nil
-          contents = nil
-        else
-          # file exists; mark cache time and read file
-          @@file_cache_time[path] = Time.now
-          contents = File.read(path)
-        end
-      else
-        # we've read this path before; may need to re-cache
-        if !File.file?(path)
-          if @@file_cache_time[path]
-            # file cached as existing but has been removed; update cache to show no file
-            change = true
-            @@file_cache_time[path] = nil
-            contents = nil
-          else
-            change = false
-          end
-        elsif !@@file_cache_time[path] ||
-              @@file_cache_time[path] < File.mtime(path) ||
-              ( File.symlink?(path) && (@@file_cache_time[path] < File.lstat(path).mtime) )
-          # cache shows file missing, or file has been modified since cached
-          change = true
-          @@file_cache_time[path] = Time.now
-          contents = File.read(path)
-        else
-          # cached file is still current; don't re-cache
-          change = false
-        end
-      end
-      
-      if change
-        @@file_cache[path] ||= block_given? ? yield(contents) : contents
-      end
-      
-      report_change ? [@@file_cache[path], change] : @@file_cache[path]
-    end 
-  end # end class methods
-  
-  ### Instance Methods
-  
-  # Creates a new controller instance, and also configures the application with the
-  # specified options.
-  def initialize(options = nil)
-    if @@options
-      self.class.merge_options(options) if options
-    else
-      self.class.load(options)
+  end  # class methods
+  
+  
+  # Creates a new application controller instance, and also configures the 
+  # application from config file options and any passed-in options.
+  def initialize(options = {})
+    # init config
+    @_config = {
+      :layout => '/_layout',
+      :file_cache_reload => true
+    }
+    @_lib_dirs = ['lib']
+    @_gem_dirs = ['gems']
+    @_require = []
+    @_authenticate_exclude = ['/login', '/logout']
+    @_exception_handlers = {}
+    @_mailer_config = {}
+    @_mailer_override = {}
+    
+    # store for cached files and directories
+    @_file_cache = {}
+    @_directory_cache = {}
+    @_file_cache_time = {}
+    
+    
+    # If options is string, then it specifies an environment
+    # (else it should be a hash of config options)
+    options = { :environment => options } if options.is_a?(String)
+  
+    # project dir
+    # all other files and directories are relative to the project dir
+    Dir.chdir(options[:project_dir] || options[:root_dir] || @@default_project_dir)
+    # save current path to force return there in case an action changes directory
+    @_project_dir = Dir.pwd
+    
+    # directory containing the config files
+    @_config_dir = options[:config_dir] || 'config'
+  
+    # get environment name from options or config/environment
+    @_environment = options[:environment] || if File.file?(env_file = @_config_dir + '/environment')
+      File.read(env_file).sub(/\s+\Z/, '')
     end
     
-    @exception_cache = {}
-    @debug_messages = []
-    @benchmarks = []
-    @files_cached_this_request = {}
-  end
-  
-  def invoke_action(path,params,render_options = {})
-    action, action_handler = get_action_handler(path,params)
-    catch :kiss_action_done do
-      action_handler.expand_login
-    
-      if @@options[:authenticate_all]
-        if (!@@authenticate_exclude.is_a?(Array) ||
-            @@authenticate_exclude.select {|a| a == action}.size == 0)
-          action_handler.authenticate
-        end
-      end
+    # read common (shared) config
+    merge_config_file(@_config_dir + '/common.yml')
+    # read environment config
+    merge_config_file(@_config_dir + "/environments/#{@_environment}.yml") if @_environment
     
-      action_handler.call
-      action_handler.render(render_options)
-    end
-    action_handler
-  end
+    # merge options passed in to override config files
+    merge_config( options )
   
-  # Processes and responds to a request received via Rack.  Should only be called once
-  # for each controller instance (i.e. each controller instance should handle at most 
-  # one request, then be discarded).  Returns array of response code, headers, and body.
-  def call(env)
-    @env = env
+    # set app instance variables from config data and defaults
+    @_action_dir = @_config[:action_dir] || 'actions'
+    @_template_dir = (@_config[:template_dir] ? @_config[:template_dir] : @_action_dir)
+    @_model_dir = @_config[:model_dir] || 'models'
+    @_evolution_dir = @_config[:evolution_dir] || 'evolutions'
     
-    # if @@rack_file && (
-    #   (env["PATH_INFO"] == '/favicon.ico') ||
-    #    (env["PATH_INFO"].sub!(Regexp.new("\\A#{@@asset_uri}"),''))
-    # )
-    #   return @@rack_file.call(env)
-    # end
+    @_asset_dir = @_public_dir = @_config[:asset_dir] || @_config[:public_dir] || 'public_html'
+    @_email_template_dir = @_config[:email_template_dir] || 'email_templates'
+    @_upload_dir = @_config[:upload_dir] || 'uploads'
     
-    # catch and report exceptions in this block
+    @_cookie_name = @_config[:cookie_name] || @@default_cookie_name
+    @_default_action = @_config[:default_action] || @@default_action
     
-    code, headers, body = begin
-      @request = Rack::Request.new(env)
-      @response = Rack::Response.new
+    # exception log
+    @_exception_log_file = @_config[:exception_log] ? ::File.open(@_config[:exception_log], 'a') : nil
     
-      @protocol, @app_host = (@request.server rescue '').split(/\:\/\//, 2)
-      @app_host = @@options[:app_host] if @@options[:app_host]
-      @app_uri = @@options[:app_uri] || @request.script_name || ''
+    # authenticate all actions?
+    @_authenticate_all = @_config[:authenticate_all]
     
-      @host ||= @request.host rescue ''
+    # don't require authentication on exception actions
+    @_authenticate_exclude << @_config.exception_action if @_config.exception_action
+    @_authenticate_exclude << @_config.file_not_found_action if @_config.file_not_found_action
     
-      path = @request.path_info || '/'
-      params = @request.params
-      
-      catch :kiss_request_done do
-        action_handler = invoke_action(path,params)
-        extension = action_handler.extension
-        
-        if content_type = options[:content_type] || (extension ? Kiss.mime_type(extension) : nil)
-          @response['Content-Type'] = "#{content_type}; #{options[:document_encoding] || 'utf-8'}"
-        end
-        
-        send_response(action_handler.output, action_handler.output_options)
-      end
-      finalize_session if @session
-      
-      @response.finish
-    rescue StandardError, LoadError, SyntaxError => e
-      body = Kiss::ExceptionReport.generate(e, env, @exception_cache, @db ? @db.last_query : nil)
-      if @@exception_log_file
-        @@exception_log_file.print(body + "\n--- End of exception report --- \n\n")
-      end
-      [500, {
-        "Content-Type" => "text/html",
-        "Content-Length" => body.length.to_s,
-        "X-Kiss-Error-Type" => e.class.name,
-        "X-Kiss-Error-Message" => e.message.sub(/\n.*/m,'')
-      }, body]
-    end
+    # app host: default hostname of application
+    @_app_host = @_config[:app_host]
+    # app uri: default URI of application
+    @_app_uri = @_config[:app_uri]
     
-    if @debug_messages.size > 0
-      extend Kiss::Debug
-      body = prepend_debug(body)
-      headers['Content-Length'] = body.length.to_s
-    end
+    # asset host: hostname of static assets
+    @_asset_host = @_config[:asset_host]
+  
+    # public_uri: URI of requests to serve from public_dir
+    @_asset_uri = @_config[:asset_uri] || @_config[:public_uri] || nil
+    @_rack_file = Rack::File.new(@_asset_dir) if @_asset_uri
     
-    if @benchmarks.size > 0
-      stop_benchmark
-      extend Kiss::Bench
-      body = prepend_benchmarks(body)
-      headers['Content-Length'] = body.length.to_s
-    end
+    # add lib dirs to load path
+    $LOAD_PATH.unshift(*( @_lib_dirs.flatten.select {|dir| File.directory?(dir) } ))
+  
+    # add gem dirs to rubygems search path
+    Gem.path.unshift(*( @_gem_dirs.flatten.select {|dir| File.directory?(dir) } ))
+  
+    # require specified libs
+    @_require.flatten.each {|lib| require lib }
     
-    if @db
-      @db.kiss_controller = nil
-      @@database_pool.push(@db)
-    end
+    # session class
+    @_session_class = @_config[:session_class]
+    @_session_class = @_session_class.to_const if @_session_class && !@_session_class.is_a?(Class)
+  
+    # database
+    @_database_config = @_config[:database]
+    @_database_pool = []
     
-    [code,headers,body]
+    self
   end
   
+  private
+  
+  # TODO: Turn exception handlers into a new class;
+  # move exception handling methods from Request to the new class
+  def prepare_exception_handler(value)
+    # start with defaults
+    {
+      :send_email => true
+    }.merge(
+      # add data from the handler config value
+      if value.is_a?(Hash)
+        value
+      elsif value.is_a?(Array)
+        value.hash_with_keys(:action, :send_email)
+      elsif value.is_a?(String)
+        { :action => value }
+      else
+        raise 'Invalid exception handler config setting.'
+      end
+    )
+  end
   
-  ##### ACTION METHODS #####
+  def merge_config_file(filename)
+    if File.file?(filename)
+      merge_config( YAML::load(File.read(filename)) )
+    end
+  end
   
-  # Parses request URI to determine action path and arguments, then 
-  # instantiates action class to create action handler.
-  def get_action_handler(path,params)
-    action_subdir = '/'
-    action_uri = ''
-    action = nil
-    args = []
-    
-    redirect_url(app_url + '/') if path == ''
-    
-    path += @@default_action if path =~ /\/\Z/
-    
-    parts = path.sub(/^\/*/,'').split('/')
-    
-    action_class = Kiss::Action.get_subclass('/', @@action_dir + '/_action.rb', self) ||
-      Kiss::Action
-    
-    while part = parts.shift
-      action_uri += '/' + part
-      
-      if part =~ /\A(\d+)\Z/ || part =~ /\A\=([\w\.\-]+)\Z/
-        args << $1
-        next
+  # Merges specified config options into previously defined/merged Kiss config.
+  def merge_config(new_config)
+    if new_config
+      if env_vars = new_config.delete(:ENV)
+        env_vars.each_pair {|k, v| ENV[k] = v }
+      end
+      if lib_dirs = new_config.delete(:lib_dirs)
+        @_lib_dirs += lib_dirs
+      end
+      if gem_dirs = new_config.delete(:gem_dirs)
+        @_gem_dirs += gem_dirs
+      end
+      if require_libs = new_config.delete(:require)
+        @_require += require_libs
       end
       
-      raise 'bad action path' if part !~ /\A[a-z][\w\-\.]*\Z/i
-      
-      test_path = @@action_dir + action_subdir + part
-      if Kiss.directory_exists?(test_path)
-        action_subdir += part + '/'
-        action_class = action_class.get_subclass(
-          part + '/',
-          @@action_dir + action_subdir + '_action.rb',
-          self
-        )
-        next
+      if auth_exclude = new_config.delete(:authenticate_exclude)
+        auth_exclude = auth_exclude.map {|action| (action[0,1] == '/') ? action : '/' + action }
+        @_authenticate_exclude += auth_exclude
       end
       
-      if part =~ /\A(.+)\.(\w+)\Z/
-        extension = $2
-        part = $1
-      else
-        extension = 'rhtml'
+      if exception_handler = new_config.delete(:exception_handler)
+        exception_handlers[Exception] = prepare_exception_handler(value)
+      end
+      if exception_handlers = new_config.delete(:exception_handlers)
+        exception_handlers.each_pair do |key, value|
+          @_exception_handlers[key == :generic ? Exception : key.to_s.to_const] = prepare_exception_handler(value)
+        end
       end
       
-      action = action_subdir + part
+      if mailer_config = new_config.delete(:mailer)
+        @_mailer_override.merge!(mailer_config.delete(:override) || {})
+        @_mailer_config.merge!(mailer_config)
+      end
+      if mailer_override = new_config.delete(:mailer_override)
+        @_mailer_override.merge!(mailer_override)
+      end
       
-      action_class = action_class.get_subclass(part, @@action_dir + action + '.rb', self)
-      break
+      @_config.merge!( new_config )
     end
-    
-    # if no action, must have traversed all parts to a directory
-    # add a trailing slash and try again
-    redirect_url(app_url + action_subdir) unless action
-    
-    # keep rest of path_info in args
-    args.push(*parts)
-    
-    # return action path and action handler (instance of action class)
-    [action, action_class.new(self,action,action_uri,action_subdir,extension,args,params)]
   end
   
+  public
   
-  ##### FILE METHODS #####
-  
-  # If file has already been cached in handling the current request, retrieve from cache
-  # and do not check filesystem for updates.  Else cache file via Kiss.file_cache.
-  def file_cache(path, *args, &block)
-    return @@file_cache[path] if @files_cached_this_request[path]
-    @files_cached_this_request[path] = true
+  def rack(config = nil)
+    merge_config(config)
+    
+    app = self
+    builder_options = @_config[:rack_builder] || []
+    rack = Rack::Builder.new do
+      builder_options.each do |builder_option|
+        if builder_option.is_a?(Array)
+          builder_args = builder_option
+          builder_option = builder_args.shift
+        else
+          builder_args = []
+        end
     
-    self.class.file_cache(path, *args, &block)
+        unless builder_option.is_a?(Class)
+          builder_option = Rack.const_get(builder_option.to_s)
+        end
+        
+        use(builder_option, *builder_args)
+      end
+      
+      run app
+    end.to_app
   end
   
+  # Runs Kiss application found at project_dir (default: '..'), with config 
+  # read from config files plus additional options if passed in.
+  def run(options = nil)
+    merge_config(options)
+    
+    handler = @_config[:rack_handler] || Rack::Handler::WEBrick
+    handler = Rack::Handler.const_get(handler.to_s) unless handler.is_a?(Class)
+    
+    handler.run(rack, @_config[:rack_handler_options] || {:Port => 4000})
+  end
   
-  ##### DATABASE METHODS #####
+  # Creates new controller instance to handle Rack request.
+  def call(env)
+    Kiss::Request.new(env, self, @_config).call(env)
+  end
   
   # Acquires and returns a database connection object from the connection pool,
   # opening a new connection if the pool is empty.
-  #
-  # Tip: `db' is a shorthand alias for `database'.
   def database
-    @db ||= @@database_pool.shift || begin
-      raise 'database config missing' unless @@database_config
+    @_database_pool.shift || begin
+      raise 'database config missing' unless @_database_config
+    
+      # open database connection
+      db = Sequel.connect @_database_config
+      load_db_class_extensions(db.class)
       
-      # open database connection (if not already open)
-      @db = @@database_config.is_a?(String) ? (Sequel.open @@database_config) :
-        @@database_config.is_a?(Hash) ? (Sequel.open @@database_config) : @@database_config
+      # create model cache for this database connection
+      db.kiss_controller = self
+      db.kiss_model_cache = Kiss::ModelCache.new(db, @_model_dir)
       
-      @@db_extras_loaded ||= begin
-        @db.class.class_eval do
-          attr_accessor :kiss_controller, :kiss_model_cache
-          
-          @last_query = nil
-          def last_query   #:nodoc:
-            @last_query
-          end
+      db
+    end
+  end
+  alias_method :db, :database
   
-          alias_method :execute_old, :execute
-          def execute(sql, *args, &block)   #:nodoc:
-            @last_query = sql
-            execute_old(sql, *args, &block)
-          end
-        end
-        
-        require 'kiss/model'
-        Kiss::ModelCache.model_dir = @@model_dir
-        
-        if @db.class.name == 'Sequel::MySQL::Database'
-          # add fetch_arrays, all_arrays methods
-          require 'kiss/sequel_mysql'
-          # turn off convert_tinyint_to_bool, unless options say otherwise
-          Sequel.convert_tinyint_to_bool = false unless @@options[:convert_tinyint_to_bool]
-        end
+  def load_db_class_extensions(db_class)
+    @_db_class_extensions_loaded ||= {}
+    @_db_class_extensions_loaded[db_class] ||= begin
+      db_class.class_eval { include Kiss::SequelDatabase }
+      
+      if db_class.name == 'Sequel::MySQL::Database'
+        # add fetch_arrays, all_arrays methods
+        Sequel::MySQL::Dataset.class_eval { include Kiss::SequelMySQLDataset }
         
-        true
+        # turn off convert_tinyint_to_bool, unless app config says otherwise
+        Sequel::MySQL.convert_tinyint_to_bool = false unless @_config[:convert_tinyint_to_bool]
       end
       
-      # TODO: rewrite evolution file exists check for speed
-      check_evolution_number
-      
-      # create model cache for this database connection
-      @db.kiss_model_cache = Kiss::ModelCache.new(@db)
-      @db.kiss_controller = self
-      
-      @db
+      require 'kiss/model'
+      true
     end
   end
-  alias_method :db, :database
   
   # Kiss Model cache, used to invoke and store Kiss database models.
   #
@@ -708,173 +385,143 @@ class Kiss
   end
   alias_method :dbm, :models
   
-  # Returns Sequel dataset to evolution_number table, which specifies app's current evolution number.
-  # Creates evolution_number table if it does not exist.
-  def evolution_number_table
-    unless db.table_exists?(:evolution_number)
-      db.create_table :evolution_number do
-        column :version, :integer, :null=> false
-      end
-      db[:evolution_number].insert(:version => 0)
-    end
-    db[:evolution_number]
-  end
-
-  # Returns app's current evolution number.
-  def evolution_number
-    evolution_number_table.first.version
+  def return_database(db)
+    @_database_pool.push(db)
   end
-
-  # Sets app's current evolution number.
-  def evolution_number=(version)
-    load unless @@options
-    evolution_number_table.update(:version => version)
-  end
-
-  # Check whether there exists a file in evolution_dir whose number is greater than app's
-  # current evolution number. If so, raise an error to indicate need to apply new evolutions.
-  def check_evolution_number
-    version = evolution_number
-    if Kiss.directory_exists?(@@evolution_dir) &&
-        Dir.entries(@@evolution_dir).select { |f| f =~ /\A0*#{version+1}_/ }.size > 0
-      raise "current evolution #{version} is outdated; apply evolutions or update evolution number"
-    end
-  end
-  
   
-  ##### SESSION METHODS #####
-  
-  # Retrieves or generates session data object, based on session ID from cookie value.
-  def session
-    @session ||= begin
-      @@session_class ? begin
-        @@session_setup ||= begin
-          # setup session storage
-          @@session_class.setup_storage(self)
-          true
-        end
-        
-        session = @@session_class.persist(self,@request.cookies[@@cookie_name])
-        @session_fingerprint = Marshal.dump(session.data).hash
-    
-        cookie_vars = {
-          :value => session.values[:session_id],
-          :path => @@options[:cookie_path] || @app_uri,
-          :domain => @@options[:cookie_domain] || @request.host
-        }
-        cookie_vars[:expires] = Time.now + @@options[:cookie_lifespan] if @@options[:cookie_lifespan]
-    
-        # set_cookie here or at render time
-        @response.set_cookie @@cookie_name, cookie_vars
-      
-        session
-      end : {}
+  # Gets the number of the last file in the evolution dir, or 0 if the directory
+  # does not exist.
+  def last_evolution_file_number
+    version = 0
+    
+    if directory_exists?(@_evolution_dir)
+      digits = 1
+      while ( entries = Dir.glob("#{@_evolution_dir}/#{'[0-9]' * digits}*") ).size > 0
+        version = entries.sort.last.sub(/.*\//, '').sub(/\D.*/, '').to_i
+        digits += 1
+      end
     end
-  end
-  
-  # Saves session to session store, if session data has changed since load.
-  def finalize_session
-    @session.save if @session_fingerprint != Marshal.dump(@session.data).hash
-  end
-  
-  # Returns a Kiss::Login object containing data from session.login.
-  def login
-    @login ||= Kiss::Login.new(session)
-  end
-  
-  
-  ##### OUTPUT METHODS #####
-  
-  # Outputs a Kiss::StaticFile object as response to Rack.
-  # Used to return static files efficiently.
-  def send_file(path, mime_type = nil)
-    @response = Kiss::StaticFile.new(path,mime_type)
     
-    throw :kiss_request_done
+    version
   end
   
-  # Prepares Rack::Response object to return application response to Rack.
-  # Raises Kiss::ActionDone exception to bypass caller stack and return directly 
-  # to Kiss#call.
-  def send_response(output = '',options = {})
-    @response['Content-Length'] = output.length.to_s
-    @response.body = output
-    
-    throw :kiss_request_done
+  # Returns an array of evolution filenames (relative to project dir) matching
+  # evolution number specified by index.
+  def evolution_file(index)
+    # find files matching ev_dir/.*next_version_number
+    files = Dir.glob("#{@_evolution_dir}/*#{index}[^0-9]*").
+      # make sure we have a match for ev_dir/0*next_version_number
+      select {|f| f =~ /\/0*#{index}[_\.][^\/]*\Z/ }
     
-    # back to Kiss#call, which finalizes session and returns @response
-    # (throws exception if no @response set)
-  end
-  
-  # Sends HTTP 302 response to redirect client browser agent to specified URL.
-  def redirect_url(url)
-    @response.status = 302
-    @response['Location'] = url
-    @response.body = ''
+    raise "multiple evolution files for evolution number #{index}" if files.size > 1
     
-    throw :kiss_request_done
+    files[0]
   end
   
   
-  ##### DEBUG/BENCH OUTPUT #####
-  
-  # Adds debug message to inspect object.  Debug messages will be shown at top of
-  # application response body.
-  def debug(object, context = Kernel.caller[0])
-    @debug_messages.push( [object.inspect, context] )
-    object
-  end
-  alias_method :trace, :debug
-  
-  # Starts a new benchmark timer, with optional label.  Benchmark results will be shown 
-  # at top of application response body.
-  def bench(label = nil, context = Kernel.caller[0])
-    stop_benchmark(context)
-    @benchmarks.push(
-      :label => label,
-      :start_time => Time.now,
-      :start_context => context
-    )
+  # Returns true if specified path is a directory.
+  # Always check filesystem if file_cache_reload option is set; otherwise, cache result.
+  def directory_exists?(dir)
+    @_config[:file_cache_reload] ? File.directory?(dir) : (
+      @_directory_cache.has_key?(dir) ?
+        @_directory_cache[dir] :
+        @_directory_cache[dir] = File.directory?(dir)
+      )
   end
   
-  # Stops last benchmark timer, if still running.
-  def stop_benchmark(end_context = nil)
-    if @benchmarks[-1] && !@benchmarks[-1][:end_time]
-      @benchmarks[-1][:end_time] = Time.now
-      @benchmarks[-1][:end_context] = end_context
+  # TODO: Move file and directory caching to new class(es)
+  # TODO: File cache should store hashes of file info, keyed by path,
+  # instead of using separate hashes (cache time, contents, etc)
+  #
+  # TODO: FIX BUG: The file cache keeps old classes after they are removed from
+  # the action/model class hierarchies.  Will the class hierarchies force reload
+  # these paths, or get the old cached versions?  Answer: They reload the classes
+  # because they only cache the source text in the file cache.  They cache the 
+  # classes in the hierarchy.
+  #
+  # TODO: Need a generic class for Action/Template/Model class hierarchy caches.
+  #
+  # Given a file path, caches or returns the file's contents or the return value of
+  # the passed block applied to the file's contents.
+  # If file is not found, the file's contents are nil.
+  def file_cache(path = nil, return_changed_state = false)
+    return @_file_cache unless path
+    
+    cache_changed = false
+    
+    if @_file_cache.has_key?(path)
+      # we've loaded this path before
+      if @_config[:file_cache_reload]
+        # check to see if there's been a change that needs to be reloaded
+        if !File.file?(path)
+          if @_file_cache_time[path]
+            # file cached as existing but has been removed; update cache to show no file
+            cache_changed = true
+            contents = nil
+          end
+        elsif !@_file_cache_time[path] ||
+              @_file_cache_time[path] < File.mtime(path) ||
+              ( File.symlink?(path) && (@_file_cache_time[path] < File.lstat(path).mtime) )
+          # cache shows file missing, or file has been modified since cached
+          cache_changed = true
+          contents = File.read(path)
+        end
+      end
+    else
+      # haven't loaded this path yet
+      cache_changed = true
+      if !File.file?(path)
+        # nil path, of file doesn't exist
+        contents = nil
+      else
+        # file exists; mark cache time and read file
+        contents = File.read(path)
+      end
+    end
+    
+    if cache_changed
+      @_file_cache_time[path] = contents ? Time.now : nil
+      @_file_cache[path] = block_given? ? yield(contents) : contents
     end
+    
+    return_changed_state ? [@_file_cache[path], cache_changed] : @_file_cache[path]
   end
   
+  # Returns new Kiss::Mailer object using specified options.
+  def new_email(options = {})
+    Kiss::Mailer.new({
+      :controller => self,
+      :request => self
+    }.merge(options))
+  end
   
-  ##### OTHER METHODS #####
+  def send_email(options = {})
+    new_email(options).send
+  end
   
   # Returns URL/URI of app root (corresponding to top level of action_dir).
+  # Part of Kiss class to be available to kiss irb.
   def app_url(options = {})
-    options.empty? ? (@app_url ||= @protocol + '://' + @app_host + @app_uri) :
-      (options[:protocol] || @protocol) + '://' + (options[:host] || @app_host) + 
-      (options[:uri] || @app_uri)
-  end
-  
-  # Returns URL/URI of app's static assets (asset_host or public_uri).
-  def pub_url(options = {})
-    options.empty? ?
-      (@pub ||= (@@asset_host ? @protocol + '://' + @@asset_host : '') + @@asset_uri) :
-      (options[:protocol] || @protocol) + '://' + (options[:host] || @@asset_host) + 
-        (options[:uri] || @@asset_uri)
+    # cache return values by unique options input
+    @_app_url_cache ||= {}
+    @_app_url_cache[options.inspect] ||= begin
+      url_settings = {
+        :protocol => @_protocol || 'http',
+        :host => @_app_host,
+        :uri => @_app_uri
+      }.merge(options)
+      
+      raise 'host missing' unless url_settings[:host]
+      
+      "#{url_settings[:protocol]}://#{url_settings[:host]}#{url_settings[:uri]}"
+    end
   end
-  alias_method :asset_url, :pub_url
   
-  # Adds data to be displayed in "Cache" section of Kiss exception reports.
-  def exception_cache(data = nil)
-    @exception_cache.merge!(data) if data
-    @exception_cache
+  def login
+    {}
   end
-  alias_method :set_exception_cache, :exception_cache
   
-  # Returns new Kiss::Mailer object using specified options.
-  def new_email(options = {})
-    mailer = Kiss::Mailer.new(options)
-    mailer.controller = self
-    mailer
+  def debug(obj, *args)
+    gdebug obj
   end
 end