IOWA 1.0.0

data/src/iowa/AbstractCache.rb

@@ -0,0 +1,96 @@
+# This file illustrates the methods that any cache implementation
+# must expose in order for IOWA to use it.  An application will
+# default to using the LRUCache unless told otherwise.
+
+require 'thread'
+require 'iowa/Constants'
+require 'iowa/Hash'
+
+module Iowa
+
+	# Caches must be thread safe.
+
+	class AbstractCache
+
+		# Initialize the empty cache.  The initialization must accept a hash as
+		# an argument, and must accept, at a minimum, the following key/value
+		# pairs in the hash as arguments:
+		#   :maxsize -- the maximum number of elements to cache.
+		#   :maxttl -- the maximum age, in seconds, of an element in the cache.
+		#
+		# Every argument to the cache must have an acceptable default value.
+
+		def initialize(args = {Cmaxsize => 20, Cttl => nil})
+			if args.kind_of? ::Hash
+				oargs = args
+				args = Iowa::Hash.new
+				args.step_merge!(oargs)
+			end
+			args.stringify_keys! if args.respond_to? :stringify_keys!
+			begin
+				@max = args[Cmaxsize] || 20
+				@maxttl = args[Cttl]
+				@mutex = Mutex.new
+			rescue Exception
+				args = {Cmaxsize => 20, Cttl => nil}
+				retry
+			end
+		end
+
+		# Check to see if the cache contains the given key.
+
+		def include?(key)
+		end
+
+		# Remove a key/value pair from the cache, by key.
+		
+		def delete(key)
+		end
+
+		# Return the element identified by the given key.
+
+		def [](key)
+		end
+		
+		# Set the element of the cache identified by the given key.  
+
+		def []=(key, val)
+		end
+
+		# Allows one to set the maximum size of the cache queue.  If the queue
+		# is currently larger than the size that it is being set to, elements
+		# will be expired until the queue is at the maximum size.
+
+		def size=(max)
+		end
+		alias maxsize= size=
+
+		# Return the maximum size of the cache.
+
+		def maxsize
+		end
+
+		# Return the current size of the cache.
+
+		def size
+		end
+
+		# Return a copy of current set of keys to cache elements.
+
+		def queue
+		end
+		
+		# Adds a finalization method to the cache that will be called before
+		# the object in the cache is expired.	
+
+		def add_finalizer(*args,&block)
+		end
+		
+		# Is called when an object in the cache is expired.  Iterates through
+		# the defined finalization methods, if any.
+
+		def do_finalization(key,obj)
+		end
+
+	end
+end

data/src/iowa/AcceptLanguage.rb

@@ -0,0 +1,76 @@
+require 'iowa/caches/LRUCache'
+require 'iowa/Constants'
+
+module Iowa
+	class AcceptLanguage
+
+		attr_accessor :default
+
+		QFRXP = /\s*;\s*/
+
+		def initialize(default = Cen)
+			@slf = {default => {}}
+			@default = default
+			@al_cache = Iowa::Caches::LRUCache.new({:maxsize => 100})
+		end
+
+		def []=(k,v)
+			language,dialect = k.split(C_dash,2)
+			if @slf.has_key?(language)
+				@slf[language][dialect] = v
+			else
+				@slf[language] = {dialect => v}
+			end
+		end
+
+		def [](v)
+			language,dialect = v.split(C_dash,2)
+			@slf.has_key?(language) ? @slf[language][dialect] : nil
+		end
+
+		def generate_language_sequence(alstring)
+			seq = []
+			alstring.split(C_comma).each do |spec|
+				language,qf = spec.split(QFRXP)
+				qf.sub!(/q=/,C_empty) if qf
+				qf = C_1_0 unless qf.to_s != C_empty
+				seq << [language,qf.to_f]
+			end
+			seq.sort_by {|a| a[1]}.reverse
+		end
+
+		def match(alstring)
+			return @al_cache[alstring] if @al_cache.include?(alstring)
+			r = nil
+			seq = generate_language_sequence(alstring)
+			seq.each do |litem|
+				language,dialect = litem.first.split(C_dash)
+				break if @slf[language] and r = @slf[language][dialect]
+			end
+			r ||= @slf[Cen][nil]
+			@al_cache[alstring] = r
+			r
+		end
+
+		def languages
+			r = []
+			@slf.each do |language,dlcts|
+				dlcts.each_key do |dialect|
+					r << (dialect ? "#{language}-#{dialect}" : language)
+				end
+			end
+			r
+		end
+			
+		def dialects(language)
+			r = []
+			if @slf.has_key?(language)
+				@slf[language].each_key do |dialect|
+					r << dialect ? "#{language}-#{dialect}" : language
+				end
+			end
+			r
+		end
+
+	end
+end

data/src/iowa/Application.rb

@@ -0,0 +1,928 @@
+require 'weakref'
+require 'thread'
+#require 'log4r'
+#include Log4r
+require 'iowa/Config'
+require 'iowa/String'
+#require 'iowa/ISAAC'
+require 'iowa/ApplicationStats'
+require 'iowa/IowaComponentMixins'
+require 'iowa/Request'
+
+module Iowa
+
+  class NoDispatcherFound < LoadError; end
+  class NoCacheFound < LoadError; end
+  class NoPolicyFound < LoadError; end
+  class NoLoggerFound < LoadError; end
+
+  # Application sits at the top of everything.  This class represents an
+  # entire Iowa application and handles the things relevant to the application
+  # as a whole.
+  #
+  # TODO: Move the configuration object into the Application and lay the
+  # groundwork for allowing more than one application in a process.
+  class Application
+
+    DocRootNames = [nil,'docs','doc','htdocs','htdoc'].freeze
+    CGIRootNames = [nil,'cgi','cgi-bin'].freeze
+    LogRootNames = [nil,'log','logs'].freeze
+
+    module ContentClasses; end
+    Content_Classes = ContentClasses
+
+    attr_accessor :location, :serial_number, :policy
+  
+    unless Object.const_defined?(:BindingCommentsRegexp)
+      BindingCommentsRegexp = /^\s*#.*$/
+    end
+
+    @applicationClass = self
+
+    def self.root_directory
+      if RUBY_VERSION =~ /^1\.8/
+        Dir.getwd # fix this
+      else
+        File.dirname( File.expand_path( Process.argv0 ) )
+      end
+    end
+
+    def self.applicationClass
+      @applicationClass
+    end
+
+    def self.applicationClass=(val)
+      @applicationClass = val
+    end
+
+    # Returns a new instance of Application
+
+    def self.newApplication(*args)
+      @applicationClass.new(*args)
+    end
+
+    # Allows one to specify a subclass to be used when creating new
+    # objects with newApplication().
+
+    def self.inherited(subclass)
+      @applicationClass = subclass
+    end
+
+    # Deprecated.  Set/use in the config file/config object.
+    def self.cachedSessions
+      Iowa.config[Capplication][Csessioncache][Cmaxsize] ||= 300
+      Iowa.config[Capplication][Csessioncache][Cmaxsize]
+    end
+  
+    def self.cachedSessions=(val)
+      Iowa.config[Capplication][Csessioncache][Cmaxsize] = val
+    end
+
+    # Deprecated.  Set/use in the config file/config object.
+    def self.cacheTTL
+      Iowa.config[Capplication][Csessioncache][Cttl]
+    end
+  
+    def self.cacheTTL=(val)
+      Iowa.config[Capplication][Csessioncache][Cttl] = val
+    end
+
+    def self.iowa_path
+      ic = Iowa.config[Capplication]
+      if ic[Ciowa_path].nil? or ic[Ciowa_path].empty?
+        ic[Ciowa_path] = [iowa_root]
+      end
+      ic[Ciowa_path]
+    end
+
+    def self.iowa_path=(val)
+      Iowa.config[Capplication][Ciowa_path] = val.is_a?(Array) ? 
+        val :
+        [val.to_s]
+    end
+
+    def iowa_path
+      self.class.iowa_path
+    end
+
+    def iowa_path=(val)
+      self.class.iowa_path = val
+    end
+
+    def self.iowa_root
+      ic = Iowa.config[Capplication]
+      if (ic[Croot_path].nil? or ic[Croot_path].empty?) and (ic[Ciowa_root].nil? or ic[Ciowa_root].empty?)
+        ic[Croot_path] = ic[Ciowa_root] = Application.root_directory
+      elsif ic[Ciowa_root].nil? or ic[Ciowa_root].empty?
+        ic[Ciowa_root] = ic[Croot_path]
+      elsif ic[Croot_path].nil? or ic[Croot_path].empty?
+        ic[Croot_path] = ic[Ciowa_root]
+      end
+      Iowa.config[Capplication][Ciowa_root]
+    end
+
+    def self.iowa_root=(val)
+      Iowa.config[Capplication][Croot_path] = Iowa.config[Capplication][Ciowa_root] = val
+    end
+
+    def iowa_root
+      self.class.iowa_root
+    end
+
+    def iowa_root=(val)
+      self.class.iowa_root = val
+    end
+
+    def self.root_path
+      iowa_root
+    end
+
+    def self.root_path=(val)
+      iowa_root = val
+    end
+
+    def root_path
+      self.class.root_path
+    end
+
+    def root_path=(val)
+      self.class.root_path = val
+    end
+
+    private
+    def self.find_app_root_dir(names,item)
+      ic = Iowa.config[Capplication]
+      if ic[item].nil? or ic[item].empty?
+        iwabd = File.dirname(iowa_root)
+        iwadr = names.inject(nil) {|dr,n| FileTest.exist?(File.join([iwabd,n].select {|x|x})) ? (dr = n) : dr}
+        ic[item] = iwadr ? File.join(iwabd,iwadr) : nil
+        ic[item]
+      else
+        ic[item]
+      end
+    end
+    public
+
+    def self.doc_root
+      dr = Iowa.config[Capplication][Cdoc_root]
+      (dr.nil? or dr.empty?) ? find_app_root_dir(DocRootNames,Cdoc_root) : dr
+    end
+
+    def self.doc_root=(val)
+      Iowa.config[Capplication][Cdoc_root] = val
+    end
+
+    def doc_root
+      self.class.doc_root
+    end
+
+    def doc_root=(val)
+      self.class.doc_root = val
+    end
+
+    def self.cgi_root
+      find_app_root_dir(CGIRootNames,Ccgi_root)
+    end
+
+    def self.cgi_root=(val)
+      Iowa.config[Capplication][Ccgi_root] = val
+    end
+
+    def cgi_root
+      self.class.cgi_root
+    end
+
+    def cgi_root=(val)
+      self.class.cgi_root = val
+    end
+
+    def self.log_root
+      find_app_root_dir(LogRootNames,Clog_root)
+    end
+
+    def self.log_root=(val)
+      Iowa.config[Capplication][Clog_root] = val
+    end
+
+    def log_root
+      self.class.log_root
+    end
+
+    def log_root=(val)
+      self.class.log_root = val
+    end
+
+    class << self
+      alias_method :iowaroot, :iowa_root
+      alias_method :iowaroot=, :iowa_root=
+      alias_method :rootpath, :root_path
+      alias_method :rootpath=, :root_path=
+      alias_method :docroot, :doc_root
+      alias_method :docroot=, :doc_root=
+      alias_method :cgiroot, :cgi_root
+      alias_method :cgiroot=, :cgi_root=
+      alias_method :logroot, :log_root
+      alias_method :logroot=, :log_root=
+    end
+    alias_method :iowaroot, :iowa_root
+    alias_method :iowaroot=, :iowa_root=
+    alias_method :rootpath, :root_path
+    alias_method :rootpath=, :root_path=
+    alias_method :docroot, :doc_root
+    alias_method :docroot=, :doc_root=
+    alias_method :cgiroot, :cgi_root
+    alias_method :cgiroot=, :cgi_root=
+    alias_method :logroot, :log_root
+    alias_method :logroot=, :log_root=
+
+    def self.ViewFileSuffixes
+      @view_suffix_src ||= nil
+    end
+
+    def self.ViewFileSuffixes=(val)
+      @view_suffix_src = val
+      @@view_suffixes = val.collect {|s| ".#{s}"}
+      @@view_regex = Regexp.new("\.#{val.join('$|\.')}$")
+      @@search_regex = Regexp.new("\.#{val.join('$|\.')}$|\\.bnd$")
+      @@view_file_regex = Regexp.new(".*\\/(.+)\\.(#{val.join('|')})")
+    end
+
+    def self.Daemonize
+      Iowa.config[Capplication][Cdaemonize] = false unless Iowa.config[Capplication][Cdaemonize].is_a?(String)
+      Iowa.config[Capplication][Cdaemonize]
+    end
+
+    def self.Daemonize=(args)
+      Iowa.config[Capplication][Cdaemonize] = args
+    end
+
+    def self.Config
+      @config ||= nil
+    end
+
+    def self.Config=(args)
+      @config = args
+    end
+
+    def self.Dispatcher
+      @dispatcher ||= nil
+    end
+
+    def self.Models
+      Iowa.config[Capplication][Cmodel][Cfiles] ||= []
+      Iowa.config[Capplication][Cmodel][Cfiles]
+    end
+
+    def self.Models=(args)
+      if args.class.kind_of?(String)
+        Iowa.config[Capplication][Cmodel][Cfiles] = [args]
+      else
+        Iowa.config[Capplication][Cmodel][Cfiles] = args
+      end
+    end
+
+    def self.Dispatcher=(args)
+      @dispatcher = Util.get_dispatcher(args)
+    end
+
+    def self.SessionCache
+      @session_cache ||= nil
+    end
+
+    def self.SessionCache=(args)
+      @session_cache = Util.get_cache(args)
+    end
+
+    def self.Policy
+      @policy ||= nil
+    end
+
+    def self.Policy=(args)
+      @policy = Util.get_policy(args)
+    end
+    
+    def self.Logger
+      @logger ||= nil
+    end
+
+    def self.Logger=(args)
+      @logger = Util.get_logger(args)
+      Logger[Ciowa_log] = @logger
+      Iowa.const_set(:Log,@logger)
+      @logger
+    end
+
+    def self.serializeCompiledTemplates
+      Iowa.config[Capplication][Cserialize_templates]
+    end
+
+    def self.serializeCompiledTemplates=(val)
+      Iowa.config[Capplication][Cserialize_templates] = val
+    end
+
+    # Performs all of the work necessary to start a new Iowa Application.
+
+    def initialize(docroot)
+      @model_mutex = Mutex.new
+      self.class.iowa_root
+      self.class.log_root
+      if self.class.Config && FileTest.exist?(self.class.Config)
+        Iowa.readConfiguration(self.class.Config)
+      else
+        Iowa.checkConfiguration
+      end
+      self.class.Logger = nil unless self.class.Logger
+
+#     begin
+#       mylog = Logger[Ciowa_log]
+#       raise "need a default logger" unless mylog
+#     rescue Exception
+#       # Logger must not be defined.  Make sure a basic default exists!
+#       require 'logger'
+#       Iowa.const_set(:Logger, {Ciowa_log => ::Logger.new(nil)})
+#       mylog = Logger[Ciowa_log]
+#     end
+
+      mylog = Iowa::Log
+      @myclass = self.class
+      @keep_statistics ||= false
+      @docroot = docroot
+      Iowa.config[Capplication][Cdocroot_caching] = false if Iowa.config[Capplication][Cdocroot_caching].nil?
+      Iowa.config[Capplication][Cdispatcher][Cclass] = 'iowa/Dispatcher' unless Iowa.config[Capplication][Cdispatcher][Cclass]
+      Iowa.config[Capplication][Cpolicy][Cclass] = 'iowa/Policy' unless Iowa.config[Capplication][Cpolicy][Cclass]
+      unless Iowa.config[Capplication][Csessioncache][Cclass]
+        Iowa.config[Capplication][Csessioncache][Cclass] = 'iowa/caches/LRUCache'
+        Iowa.config[Capplication][Csessioncache][Cmaxsize] = 300
+        Iowa.config[Capplication][Csessioncache][Cttl] = nil
+      end
+
+      Iowa.config[Capplication][Cpath_query_interval] = int_or_nil(Iowa.config[Capplication][Cpath_query_interval])
+      Iowa.config[Capplication][Creload_interval] = int_or_nil(Iowa.config[Capplication][Creload_interval])
+
+      self.class.Dispatcher = nil unless  self.class.Dispatcher
+      self.class.SessionCache = nil unless self.class.SessionCache
+      self.class.SessionCache.add_finalizer {|key, obj| obj.lock = nil}
+      self.class.Policy = nil unless self.class.Policy
+      @sessions = self.class.SessionCache
+      @policy = self.class.Policy
+      self.class.ViewFileSuffixes = %w(htm html vew view) unless self.class.ViewFileSuffixes
+      Iowa.config[Capplication][Cserialize_templates] = false unless Iowa.config[Capplication][Cserialize_templates] and (Iowa.config[Capplication][Cserialize_templates] == true or !Iowa.config[Capplication][Cserialize_templates].empty?)
+      @templateCache = {}
+      @templateMTimes = Hash.new {|h,k| h[k] = Time.at(1)}
+      @templateLTimes = {}
+      @templateRTimes = Hash.new {|h,k| h[k] = Time.at(1)}
+      @pathNameCache = {}
+      @appLock = Mutex.new
+      @statistics = Iowa::ApplicationStats.new(@sessions)
+      @reload_scan_mode = Csingular
+      $iowa_application = self
+
+      Iowa.config[Capplication][Cmodel][Cinterval] ||= 300
+      Iowa.config[Capplication][Cmodel][Cvariation] ||= 60
+      if self.class.Models.empty?
+        bn = File.basename($0)
+        ['models/','model.rb',bn.sub(/\.\w+$/,'.mdl'),bn.sub(/\.\w+$/,'.model')].each do |m|
+          self.class.Models << m if FileTest.exist? m
+        end
+      end
+      model_monitor
+      Thread.start {model_monitor(true)}
+
+      self.class.doc_root
+      self.class.cgi_root
+      self.class.log_root
+
+      mylog.info "  Application with docroot of #{docroot} initialized."
+      mylog.info "    docroot_caching is #{Iowa.config[Capplication][Cdocroot_caching] ? 'enabled' : 'disabled'}"
+    end
+
+    private
+    def int_or_nil(n)
+      Integer(n)
+    rescue
+      nil
+    end
+    public
+
+    def read_model(model)
+      Logger[Ciowa_log].info "Loading model #{model}."
+      load model
+    end
+
+    def model_mtime(path)
+      mtime = File.stat(path).mtime
+      Logger[Ciowa_log].info "#{path} : #{mtime} != #{@model_mtimes[path]}"
+      if mtime != @model_mtimes[path]
+        @model_mtimes[path] = mtime
+        true
+      else
+        false
+      end
+    end
+
+    def model_monitor(doloop = false)
+      @model_mtimes = {}
+      begin
+        if doloop
+          sleep_time Iowa.config[Capplication][Cmodel][Cinterval] + rand(Iowa.config[Capplication][Cmodel][Cvariation].to_i)
+          Logger[Ciowa_log].info "model monitor sleeping for #{sleep_time} seconds"
+          sleep(sleep_time)
+        end
+        @model_mutex.synchronize do
+          self.class.Models.each do |model|
+            Logger[Ciowa_log].info "model #{model}"
+            next unless FileTest.exist? model
+            if FileTest.directory? model
+              Logger[Ciowa_log].info "  directory"
+              require 'find'
+              Find.find(model) do |path|
+                Logger[Ciowa_log].info "    checking #{path}"
+                next if FileTest.directory? path
+                read_model(path) if model_mtime(path)
+              end
+            else
+              read_model(model) if model_mtime(model)
+            end
+          end
+        end
+      end while doloop
+    end
+
+    def rendered_content
+      @rendered_content ||= Iowa::Caches::LRUCache.new({:maxsize => 100})
+    end
+
+    def rand(num)
+      @policy.rand(num)
+    end
+
+    def statistics
+      @statistics
+    end
+  
+    def reload_scan_mode
+      @reload_scan_mode
+    end
+  
+    # Set the reload scanning mode.  The two current settings are 'singular'
+    # and 'plural'.
+    #   singular: only check the named template for loading.  This is much
+    #     more efficient for large applications as it eliminates making a stat()
+    #     system call on each file for every single request.  Most of the time
+    #     this should be sufficient for detecting any changes that have been
+    #     made and reloading them.  If, in some case, it is found not to be
+    #     sufficient, one can set the mode to 'plural' which is the old
+    #     normal mode of operation.  'singular' is the default mode of
+    #     operation.
+    #   plural: checks the mtime of every file in the iowa docroot directory
+    #     every time a request is handled.  This is guaranteed to detect
+    #     and reload changes in every file.  For sites that have a lot of
+    #     files in their docroot, though, this is a performance hit.
+    #     There really should never be a need to run in plural mode
+    #     so this is deprecated and will be removed soon.
+    def reload_scan_mode=(mode)
+      if mode == Csingular
+        @reload_scan_mode = Csingular
+      else
+        @reload_scan_mode = Cplural
+      end
+    end
+
+    # Dispatches the request to the session.  This can be overridden in order to
+    # make more complex decisions about which page to display, but the prefered
+    # approach is to leave this method alone and to provide a custom dispatcher.
+
+    def dispatcher(session,context,dispatch_destination = nil)
+      @myclass.Dispatcher.dispatch(session,context,dispatch_destination)
+    end
+  
+    # handleRequest() is called whenever a request is made to the application.
+  
+    def handleRequest(context,dispatch_destination = nil)
+      session = exception = nil
+      @statistics.hit if @keep_statistics
+      # ToDo: Clean this up so that we can make it work with only
+      # one begin/end block, or even better, with just rescue clauses.
+      begin
+        unless context.sessionID.to_s != C_empty
+          context.sessionID = @policy.new_session_key
+          @sessions[context.sessionID] = Session.newSession
+          @sessions[context.sessionID].application = self
+        end
+        session = @sessions[context.sessionID] unless exception
+      rescue Exception => exception
+        throw :session_error,exception
+      end
+      if session
+        dispatcher(session,context,dispatch_destination)
+      else
+        begin
+          invalidSession(context)
+        rescue Exception => exception
+        end
+        if exception
+          throw :session_error,exception
+        end
+      end
+    end
+
+    def search_proc(dirpath)
+      r = []
+      Dir.foreach(dirpath) do |filename|
+        next if filename == C_dot or filename == C_dotdot or filename =~ /^\./ or filename =~ /^[a-z]/
+        fullname = "#{dirpath}/#{filename}"
+        if FileTest.directory? fullname
+          r << search_proc(fullname)
+        elsif @@search_regex.match(filename)
+          r.push fullname.gsub(/\/\//,C_slash)
+        end
+      end
+      r
+    end
+
+    # Reload a component if it has changed.
+  
+    def reloadModified(component_class=nil,only_if_singular=nil,import_call=false)
+      unless @templateRTimes[component_class.to_s] > Time.now
+        @templateRTimes[component_class.to_s] = Time.now + reload_interval
+        pathlist = nil
+        classname = component_class.to_s.split(ClassSeparator).last.to_s
+        if (reload_scan_mode == Csingular and !classname.nil?)
+          pathlist = [pathForName(component_class)].compact
+        elsif (reload_scan_mode != Csingular and !only_if_singular)
+          pathlist = search_proc(@docroot)
+        end
+    
+        if pathlist
+          if import_call
+            reloadLoop(pathlist)
+          else
+            reloadLoop(pathlist)
+          end
+        end
+      end
+    end
+
+    # Check the modification time on the template files in order to
+    # determine if the template needs to be reloaded.
+    
+    def checkMtime(path)
+      file = File.new(path)
+      fileMtime = file.mtime
+
+      iwaPath = path.sub(@@view_regex, C_iwa)
+      if File.exist?(iwaPath)
+        iwaMtime = File.stat(iwaPath).mtime
+        fileMtime = iwaMtime if iwaMtime > fileMtime
+      end
+      
+      
+      
+      bndPath = path.sub(@@view_regex,C_bnd)
+      if File.exist?(bndPath)
+        bndMtime = File.stat(bndPath).mtime
+        fileMtime = bndMtime if bndMtime > fileMtime
+      end
+
+      fileMtime
+
+    rescue Exception => e
+      Logger['iowa_log'].error e.to_s
+      Time.at(1)
+    end
+
+    def reload_interval
+      Iowa.config[Capplication][Creload_interval] || 60
+    end
+
+    def reloadLoop(pathlist)
+      return unless pathlist
+      mylog = Logger[Ciowa_log]
+      pathlist.each do |path|
+        next if @templateRTimes[path] > Time.now
+        mtime = @templateMTimes[path]
+        next if Time.now < (mtime + reload_interval)
+        @templateRTimes[path] = Time.now + reload_interval
+  
+        fileMtime = checkMtime(path)
+  
+        unless mtime and mtime >= fileMtime
+          mylog.info "Loading template #{path}"
+          reload File.new(path)
+          @templateMTimes[path] = fileMtime
+        end
+      end
+    end
+
+    def initialLoad
+      mylog = Logger[Ciowa_log]
+      # There really shouldn't be any reason to load all of the files
+      # initially anymore, but just in case, we'll still allow it via
+      # a config setting.
+      unless Iowa.config[Capplication][Cdo_initial_load]
+        mylog.info "Not loading any files initially."
+        return
+      end
+      
+      search_proc = proc do |dirpath|
+        r = []
+        Dir.foreach(dirpath) do |filename|
+          next if filename == C_dot or filename == C_dotdot or /^\./.match(filename) or /^[a-z]/.match(filename)
+          fullname = "#{dirpath}/#{filename}"
+          if FileTest.directory? fullname
+            r << search_proc.call(fullname)
+          elsif @@view_regex.match(filename)
+            r.push fullname
+          end
+        end
+        r.flatten.sort
+      end
+
+      pathlist = search_proc.call(@docroot)
+
+      reloadLoop(pathlist)
+    end
+
+    # Returns the template that implements the named component.
+
+    def templateForComponent(name)
+      template = nil
+      pfn = pathForName(name)
+      if @templateCache.has_key? pfn
+        if @templateCache[pfn].respond_to? :weakref_alive?
+          rtc = 0
+          begin
+            template = @templateCache[pfn].self
+          rescue Exception => e
+            Logger[Ciowa_log].info "Error: #{e}\n#{e.backtrace.join("\n")}"
+            #reload(File.new(pathForName(name)))
+            reload(File.new(pfn))
+            rtc += 1
+            if rtc < 3
+              retry
+            else
+              raise e
+            end
+          end
+        else
+          template = @templateCache[pfn]
+        end
+      else
+        
+        #reload(File.new(pathForName(name)))
+        reload(File.new(pfn)) if pfn
+        template = @templateCache[pfn]
+      end
+      template
+    end
+
+    # import is used to make other templates available within the
+    # context of the template where it is called.
+
+    def import(name,namespace = nil)
+      # TODO: Deal with recursion.  If A imports B and B imports A, we
+      # will get stuck.
+      namespace = namespace.gsub(ContentClassesNamespace,C_empty).gsub(/^::/,C_empty)
+      ft = File.join(@docroot,namespace.gsub(ClassSeparator,C_slash),name)
+      template_class = nil
+      if namespace != C_empty
+        @@view_suffixes.each do |suffix|
+          if FileTest.exist?("#{ft}#{suffix}")
+            template_class = "#{namespace}::#{name}"
+            break
+          end
+        end
+      end
+      template_class = name unless template_class
+
+      if reload_scan_mode == Csingular
+        reloadModified(template_class,true,true)
+      else
+        reload File.new(pathForName(template_class))
+      end
+    end
+
+    private
+
+    def path_query_interval
+      Iowa.config[Capplication][Cpath_query_interval] || 60
+    end
+  
+    # Given a component name, finds the path to it.
+
+    def pathForName(name)
+      name.gsub!(/Iowa::Application::ContentClasses::/,C_empty)
+      return @pathNameCache[name] if @templateLTimes.has_key?(name) and (@templateLTimes[name] < Time.now)
+      my_docroot = @docroot
+      my_docroot << C_slash unless my_docroot[-1,1] == C_slash
+    
+      pfn_pre = my_docroot + name.gsub(/::/,C_slash)
+      pfn = nil
+      @@view_suffixes.each do |sfx|
+        tmp_pfn = pfn_pre + sfx
+        if FileTest.exist? tmp_pfn
+          pfn = tmp_pfn
+          @pathNameCache[name] = pfn
+          @templateLTimes[name] = Time.now + path_query_interval
+          break
+        end
+      end
+      pfn
+    end
+
+    # Extract the code and bindings from the code data.
+  
+    def get_code_and_bindings(codedata)
+      codedata.sub!(/<\?(.*?)\?>/m, C_empty)
+      bindings = ''
+      bindings = $1.gsub(BindingCommentsRegexp,C_empty) if $1
+      if m = /<%(.*?)%>/m.match(codedata)
+        code = m[1]
+      else
+        code = codedata
+      end
+      [code,bindings]
+    end
+
+    # This method loads (or reloads) a template file.
+    # To completely separate the layout (template) from the code,
+    # put the HTML in a file Foo.html, and then place the code for
+    # that template into another file, Foo.iwa.
+
+    def reload(file)
+      mylog = Logger[Ciowa_log]
+      data = file.read
+    
+      code_text = ''
+      bindings_text = ''
+    
+      # Read the codefile and check for bindings embedded into it.
+      codefile_path = file.path.sub(@@view_regex,C_iwa)
+      if FileTest.exist?(codefile_path) and FileTest.readable?(codefile_path)
+        File.open(codefile_path) do |codefile|
+          codedata = codefile.read.gsub(/\cM/,C_empty)
+          code_text, bindings_text = *get_code_and_bindings(codedata)
+        end
+      else
+        codedata = data.gsub(/\cM/,C_empty)
+        unless /<%.*?%>/m.match(codedata)
+          codedata,codefile_path = defaultScript(file)
+          codedata.gsub!(/\cM/,C_empty)
+          code_text, bindings_text = *get_code_and_bindings(codedata)
+        else
+          codefile_path = file.path
+          codedata.sub!(/<%(.*?)%>/m, C_empty)
+          code_text = $1
+          codedata.sub!(/<\?(.*?)\?>/m, C_empty)
+          bindings_text = $1.gsub(BindingCommentsRegexp,C_empty) if $1
+          data = codedata
+        end
+      end
+    
+      # Now check for a dedicated bindings file.
+      # In a dedicated bindings file, one can have multiple bindings
+      # blocks with comments (lines with a first non-whitespace character
+      # of #) anywhere.  This is just a feature to allow for some intelligent
+      # organization of bindings and comments, if desired.
+      bindingfile_path = file.path.sub(@@view_regex,C_bnd)
+      if FileTest.exist?(bindingfile_path) and FileTest.readable?(bindingfile_path)
+        File.open(bindingfile_path) do |bindingfile|
+          bindingdata = bindingfile.read.gsub(/\cM/,C_empty)
+          bindingdata = bindingdata.gsub(/<\?/,C_empty).gsub(/\?>/,C_empty).gsub(BindingCommentsRegexp,C_empty) if bindingdata
+          bindings_text << bindingdata
+        end
+      end
+    
+      # There's a bit of magic that has to occur, now.  In order to
+      # support the notion of the subdirectory that the script file
+      # is found in relating to the namespace (using modules as
+      # namespace) for the component, reload() needs to figure out
+      # just what the namespace is supposed to be for the file, then
+      # check to see if that namespace has a already been created,
+      # create it if it has not, and finally eval the script file
+      # content within the context of the namespace (module).
+    
+      # First, what's the namespace?  Basically, we subtract the
+      # Iowa docroot from the file path and see what is left.
+    
+      my_docroot = @docroot
+      my_docroot << C_slash unless my_docroot[-1,1] == C_slash
+      script_namespace_parts = file.path.gsub(/^#{my_docroot}/,C_empty).split(C_slash).reject {|x| x == C_empty}
+      script_namespace_parts.delete(C_dot)
+      script_namespace_parts.delete(C_dotdot)
+      class_name = script_namespace_parts.pop.split(C_dot)[0]
+      script_namespace_parts.unshift(CContentClasses)
+    
+      script_namespace = (['Iowa::Application'] + script_namespace_parts).join(ClassSeparator)
+
+      pre = ''
+      post = ''
+    
+      script_namespace_parts.each do |sym|
+        pre << "module #{sym}; extend IowaComponentMixins;"
+        post << "end;"
+      end
+      
+      mylog.info "Creating namespace #{script_namespace}"
+      eval(pre + post)
+      eval(script_namespace)
+      namespace_class = script_namespace.split(ClassSeparator).inject(Object) { |o,n| o.const_get n }
+  
+      begin 
+        # Now execute our code within the namespace.
+
+        namespace_class.class_eval(code_text,codefile_path)
+        new_class = "#{script_namespace}::#{class_name}".split(ClassSeparator).inject(Object) { |o,n| o.const_get n }
+
+        bindings = BindingsParser.new((bindings_text ? bindings_text : C_empty),new_class).bindings
+
+        fdn = File.dirname(file.path)
+        compiled_template_file = File.join(fdn,".#{new_class.name}.iwt")
+        load_precompiled = false
+        if FileTest.exist?(compiled_template_file) and File.mtime(compiled_template_file) > checkMtime(file.path)
+          begin
+            mylog.info "Loading precompiled template: #{compiled_template_file}"
+            @templateCache[file.path] = WeakRef.new(Marshal.load(File.read(compiled_template_file)))
+            load_recompiled = true
+          rescue Exception => e
+            mylog.info "Error with precompiled template: #{e}"
+          end
+        end
+        unless load_recompiled
+          mylog.info "Parsing #{file.path} into template cache"
+          if self.class.serializeCompiledTemplates && new_class.serializeCompiledTemplate
+            @templateCache[file.path] = WeakRef.new(TemplateParser.new(data, bindings,new_class,fdn).root)
+          else
+            @templateCache[file.path] = TemplateParser.new(data, bindings,new_class,fdn).root
+          end
+          Logger[Ciowa_log].info("  Done parsing #{file.path}")
+        end
+      rescue Exception => e
+        mylog.info "There was an error while processing #{file.path}:\n#{e.to_s}\n#{e.backtrace}\n"
+      end
+    end
+
+    # If there is only an HTML file, without either an embedded code section
+    # or a corresponding .iwa file, then we apply a basic default.
+    # If a file, 'DefaultScriptFile.iwa', exists in the Iowa docroot, the
+    # contents of that file will be used for the default script.  That file
+    # should be written as a standard Iowa .iwa file, with one exception.
+    # The exception is that the name of the class should be written as:
+    #   [--CLASSNAME--]
+    # This placeholder will be expanded by Iowa into the actual name of the
+    # class to be created.
+    
+    def defaultScript(file)
+      mylog = Logger[Ciowa_log]
+  
+      #name = /.*\/(.+)\.(view|vew|html|htm)/.match(file.path)[1]
+      name = @@view_file_regex.match(file.path)[1]
+      r = ''
+    
+      my_docroot = @docroot
+      my_docroot << C_slash unless my_docroot[-1,1] == C_slash
+      my_docroot_minus_slash = my_docroot.sub(/\/$/,C_empty)
+      filepath = file.path
+      filepath.sub!(/#{my_docroot}/,C_empty)
+    
+      path_parts = filepath.split(C_slash)
+      # Knock the filename off of the array.
+      path_parts.pop
+      # And put the docroot path onto the beginning of the array.
+      path_parts.unshift my_docroot_minus_slash
+      df_found = nil
+      search_path = ''
+      while path_parts.length > 0
+        search_path << "#{path_parts.shift}/"
+        default_script_file = search_path + 'DefaultScriptFile.iwa'
+        default_script_file.gsub(/\/\//,C_slash)
+        if FileTest.exists? default_script_file
+          df_found = default_script_file
+        end
+      end
+    
+      if df_found
+        File.open(df_found,'r') do |fh|
+          fh.each {|line| r << line}
+        end
+        mylog.info "Loaded #{df_found} for script file for #{file.path}"
+      else
+        r << "<%class [--CLASSNAME--] < Iowa::Component; end%>"
+        df_found = 'INTERNAL'
+        mylog.info "Used basic scriptfile for #{file.path}"
+      end
+    
+      r.gsub!(/\[--CLASSNAME--\]/,name)
+      [r,df_found]
+    end
+
+
+    # Make this something that can be configured.
+    
+    def invalidSession(context)
+      context.response << "<html><head><meta http-equiv=REFRESH content='1; URL=#{context.baseURL}'></head><body><b>That session no longer exists (#{$$}:#{$$.to_s(16)}).<p>You are being forwarded to a <a href='#{context.baseURL}'>new session</a>.</b></body></html>"
+    end
+
+  end
+
+end