IOWA 1.0.0

data/src/iowa/caches/LRUCache.rb

@@ -0,0 +1,290 @@
+require 'enumerator'
+require 'thread'
+require 'iowa/Constants'
+require 'iowa/Hash'
+
+module Iowa
+	module Caches
+
+		#++
+		# Iowa::Caches::LRUCache is an LRU cache based on a linked list.
+		# It provides efficient random access to elements, like a hash,
+		# along with efficient stack or queue-like behaviors -- elements can
+		# be pushed, poped, shifted, and unshifted from the cache.
+		
+		class LRUCache
+			include Enumerable
+
+			# * Iowa::Caches::LRUCache.new
+			# * Iowa::Caches::LRUCache.new(:maxsize => 20)
+			# * Iowa::Caches::LRUCache.new(20)
+			# * Iowa::Caches::LRUCache.new(:maxsize => 20, :ttl => 3600)
+			# * Iowa::Caches::LRUCache.new(20,3600)
+			#
+			# If called with no arguments, the cache will default to a max size
+			# of 20 elements, with no max time to live (ttl) on the elements.
+			#
+			# If called using a hash with keyword arguments, the :maxsize is the
+			# maximum number of elements to keep in the hash, and :ttl is the 
+			# maximum age allowed for elements in the hash.
+			#
+			# If called with list arguments, the first is the max size, and the
+			# second is the TTL.
+			
+			def initialize(args = {Cmaxsize => 20, Cttl => nil}, ttlarg = 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 => args || 20, Cttl => ttlarg}
+					retry
+				end
+				@finalizers = []
+				@head = Node.new
+				@tail = Node.new
+				@lookup = Hash.new
+				node_join(@head,@tail)
+			end
+
+			
+			# Check to see if the given key is in the cache.
+
+			def include?(v)
+				@lookup.has_key?(v)
+			end
+			alias :has_key? :include?
+
+			def [](v)
+				@mutex.lock
+				if @lookup.has_key?(v)
+					n = @lookup[v]
+					n.age = Time.now
+					node_delete(n)
+					node_join(n,@head.next_node)
+					node_join(@head,n)
+					node_prune
+					@mutex.unlock
+					n.value
+				else
+					node_prune
+					@mutex.unlock
+					nil
+				end
+			end
+
+			def []=(k,v)
+				@mutex.lock
+				if @lookup.has_key?(k)
+					n = @lookup[k]
+					n.value = v
+					n.age = Time.now
+					node_delete(n)
+					node_join(n,@head.next_node)
+					node_join(@head,n)
+				else
+					n = Node.new(k,v,Time.now,@head,@head.next_node)
+					node_join(n,@head.next_node)
+					node_join(@head,n)
+					@lookup[k] = n
+				end
+				node_prune
+				@mutex.unlock
+				v
+			end
+
+			def empty?
+				@lookup.empty?
+			end
+
+			def delete(k)
+				@mutex.lock
+				n = @lookup.delete(k)
+				node_purge(n) if n
+				node_prune
+				@mutex.unlock
+				n.value
+			end
+
+			def first
+				@head.next_node.value
+			end
+
+			def last
+				@tail.prev_node.value
+			end
+
+			def shift
+				@mutex.lock
+				k = @head.next_node.key
+				n = @lookup.delete(k)
+				node_delete(n) if n
+				node_prune
+				@mutex.unlock
+				n.value
+			end
+
+			def unshift(v)
+				@mutex.lock
+				if @lookup.has_key?(v)
+					n = @lookup[v]
+					node_delete(n)
+					node_join(n,@head.next_node)
+					node_join(@head,n)
+				else
+					n = Node.new(v,v,Time.now,@head,@head.next_node)
+					node_join(n,@head.next_node)
+					node_join(@head,n)
+					@lookup[v] = n
+				end
+				node_prune
+				@mutex.unlock
+				v
+			end
+
+			def pop
+				@mutex.lock
+				k = @tail.prev_node.key
+				n = @lookup.delete(k)
+				node_delete(n) if n
+				node_prune
+				@mutex.unlock
+				n.value
+			end
+
+			def push(v)
+				@mutex.lock
+				if @lookup.has_key?(v)
+					n = @lookup[v]
+					node_delete(n)
+					node_join(@tail.prev_node,n)
+					node_join(n,@tail)
+				else
+					n = Node.new(v,v,Time.now,@tail.prev_node,@tail)
+					node_join(@tail.prev_node,n)
+					node_join(n,@tail)
+					@lookup[v] = n
+				end
+				node_prune
+				@mutex.unlock
+				v
+			end
+
+			def queue
+				r = []
+				n = @head
+				while (n = n.next_node) and n != @tail
+					r << n.key
+				end
+				r
+			end
+	
+			def to_a
+				r = []
+				n = @head
+				while (n = n.next_node) and n != @tail
+					r << n.value
+				end
+				r
+			end
+	
+			def length
+				@lookup.length
+			end
+			alias :size :length
+	
+			def each
+				n = @head
+				while (n = n.next_node) and n != @tail
+					yield(n.key,n.value)
+				end
+			end
+
+			def maxsize
+				@max
+			end
+
+			def maxsize=(v)
+				@max = v
+				node_prune
+			end
+			alias :size= :maxsize=
+
+			def ttl
+				@maxttl
+			end
+
+			def ttl=(v)
+				@maxttl = v
+				node_prune
+			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)
+				@finalizers.push [block,args]
+			end
+			
+			private
+	
+			def node_delete(n)
+				node_join(n.prev_node,n.next_node)
+			end
+	
+			def node_purge(n)
+				node_join(n.prev_node,n.next_node)
+				v = n.value
+				k = n.key
+				n.value = nil
+				n.key = nil
+				n.next_node = nil
+				n.prev_node = nil
+				do_finalization(k,v) if @finalizers
+				v
+			end
+
+			def node_join(a,b)
+				a.next_node = b
+				b.prev_node = a
+			end
+
+			def node_prune
+				node_purge(@lookup.delete(@tail.prev_node.key)) while @lookup.size > @max
+				if @maxttl
+					expiration_date = Time.now - @maxttl
+					while (n = @tail.prev_node) and n != @head and n.age < expiration_date
+						node_purge(@lookup.delete(n.key))
+					end
+				end
+			end
+
+			# Is called when an object in the cache is expired.  Iterates through
+			# the defined finalization methods, if any.
+			def do_finalization(key,obj)
+				@finalizers.each do |f|
+					f[0].call(key,obj,*f[1])
+				end
+			end
+
+			class Node
+				attr_accessor :key, :value, :age, :prev_node, :next_node
+
+				def initialize(key=nil,value=nil,age=Time.now,prev_node=nil,next_node=nil)
+					@key = key
+					@value = value
+					@age = age
+					@prev_node = prev_node
+					@next_node = next_node
+				end
+			end
+
+		end
+	end
+end

data/src/iowa/caches/SimpleLRUCache.rb

@@ -0,0 +1,112 @@
+# This cache is based off of the LRUCache found in Facets
+# (http://facets.rubyforg.org) version 1.7.30, which was
+# contributed by George Moscovitis.
+
+module Iowa
+	module Caches
+		class SimpleLRUCache < Hash
+
+			# Mix this in your class to make LRU-managable.
+
+			module Item
+				attr_accessor :lru_key, :lru_prev, :lru_next
+			end
+
+			class Sentinel; include Item; end
+
+			attr_accessor :max_items
+			attr_reader :head, :tail
+
+			def initialize(args = {Cmaxsize => 20, Cttl => nil})
+				@finalizers = []
+		    lru_clear()
+				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_items = args[Cmaxsize] || 20
+					@ttl = args[Cttl]
+					@timer = nil
+  		  	lru_clear()
+				rescue Exception
+					args = {Cmaxsize => args || 20, Cttl => nil}
+					retry
+				end
+		  end
+
+			def [](key)
+				if item = super
+					lru_touch(item)
+				end
+			end
+
+			def []=(key, item)
+				item = super
+				item.lru_key = key
+				lru_insert(item)
+			end
+
+			def delete(key)
+				lru_delete(item) if item = super
+			end
+
+			def clear
+				super
+				lru_clear()
+			end
+
+			def first
+				@head.lru_next
+			end
+
+			def last
+				@tail.lru_prev
+			end
+			alias_method :lru, :last
+
+			def add_finalizer(*args,&block)
+				@finalizers.push [block,args]
+			end
+
+			private
+
+			def lru_delete(item)
+				lru_join(item.lru_prev, item.lru_next)
+				item
+			end
+
+			def lru_join(x, y)
+				x.lru_next = y
+				y.lru_prev = x
+				y
+			end
+
+			def lru_append(parent, child)
+				lru_join(child, parent.lru_next)
+				lru_join(parent, child)
+			end
+
+			def lru_insert(item)
+				lru_append(@head, item)
+				delete(last.lru_key) if size() > @max_items
+			end
+
+			def lru_touch(item)
+				lru_append(@head, lru_delete(item))
+			end
+
+			def lru_clear
+				@head = Sentinel.new
+				@tail = Sentinel.new
+				lru_join(@head, @tail)
+			end
+
+			def do_finalization(key,obj)
+				@finalizers.each {|f| f[0].call(key,obj,*f[1])}
+			end
+		end
+	end
+end

data/src/iowa/dispatchers/StandardDispatcher.rb

@@ -0,0 +1,396 @@
+require 'thread'
+require 'iowa/Hash'
+require 'iowa/Request'
+require 'iowa/KeyValueCoding'
+require 'iowa/caches/LRUCache'
+
+module Iowa
+	module Dispatchers
+		class StandardDispatcher
+			attr_accessor :mapfile
+			
+			class NoMapFile < Exception; end
+
+			# {:mapfile => 'FILENAME', :poll_interval => 30, :map => {'/foo/bar.html' => 'Bar'}, :rewrites => [], :secondary_rewrites => []}
+			def initialize(*args)
+				@mutex = Mutex.new
+				@mapfileMTime = Time.at(1)
+				@next_check = Time.at(1)
+				if args[0].respond_to?(:[])
+					if args[0].kind_of?(::Hash)
+						oargs = args[0]
+						args = Iowa::Hash.new
+						args.step_merge!(oargs)
+					end
+					args.stringify_keys! if args.respond_to? :stringify_keys!
+					@mapfile = args[Cmapfile]
+					@poll_interval = args['poll_interval'] ? args['poll_interval'].to_i : 30
+					@path_map = args['map'] || {}
+					@rewrites = RuleSet.new(args['rewrites'] || [])
+					@secondary_rewrites = RuleSet.new(args['secondary_rewrites'] || [])
+				else
+					@mapfile = args[0]
+					@poll_interval = args[1] ? args[1].to_i : 30
+					@path_map = args[2] || {}
+					@rewrites = RuleSet.new(args[3] || [])
+					@secondary_rewrites = RuleSet.new(args[4] || [])
+				end
+
+				raise(NoMapFile, "The mapfile (#{@mapfile}) does not appear to exist.") if !FileTest.exist?(@mapfile.to_s) if @mapfile
+				@mapfile ||= 'mapfile.map' if FileTest.exist?('mapfile.map')
+				check_mapfile
+				@mapfile
+			end
+
+			# Checks to see if the mapfile needs to be reloaded.  To avoid
+			# a deluge of stat() calls, it will only check once every
+			# @poll_interval seconds (set during initialization; defaults to
+			# 30 seconds).
+			
+			def check_mapfile
+				if @mapfile and @next_check < Time.now
+					@mutex.synchronize do
+						@next_check = Time.at(Time.now + @poll_interval)
+						if File.stat(@mapfile).mtime != @mapfileMTime
+							load_mapfile
+						end
+					end
+				end
+			end
+
+			# Loads @mapfile.
+			
+			def load_mapfile
+				raw_data = {}
+				File.open(@mapfile) do |mf|
+					rd = YAML::load(mf)
+					break unless rd.respond_to?(:has_key?)
+					raw_data = Iowa::Hash.new
+					raw_data.step_merge!(rd)
+					raw_data.symbolify_keys!
+					rs = raw_data.has_key?(:rewrites) ? raw_data[:rewrites] : []
+					@rewrites = RuleSet.new(rs)
+					rs = (raw_data.respond_to?(:[]) and raw_data.has_key?(:secondary_rewrites)) ? raw_data[:secondary_rewrites] : []
+					@secondary_rewrites = RuleSet.new(rs)
+					@path_map = (raw_data.respond_to?(:[]) and raw_data.has_key?(:map)) ? raw_data[:map] : {}
+					if raw_data.respond_to?(:delete)
+						raw_data.delete(:rewrites)
+						raw_data.delete(:secondary_rewrites)
+						raw_data.delete(:map)
+					end
+					raw_data.each {|k,v| @path_map[k] = v if (k.class.is_a?(String) and v.class.is_a?(String))}
+					@mapfileMTime = mf.mtime
+					end
+			end
+
+			# Returns true if the dispatcher is willing to handle this request.
+	
+			def handleRequest?(request)
+				check_mapfile
+				if !Iowa.app.policy.getIDs(request.uri)[1].nil?
+					true
+				else
+					process(request)
+				end
+			end
+		
+			# Dispatches the request.
+		 
+			def dispatch(session,context,dispatch_destination = nil)
+				unless dispatch_destination or context.actionID
+					request = context.request
+					check_mapfile
+					dispatch_destination = process(request)
+				end
+				session.handleRequest(context,dispatch_destination)
+			end
+
+			def process(request)
+				dd = @rewrites.process(request)
+				return dd if dd.is_a?(Iowa::DispatchDestination)
+				if c = @path_map[request.uri]
+					return Iowa::DispatchDestination.new(c)
+				else
+					dd = @secondary_rewrites.process(request)
+					return dd if dd.is_a?(Iowa::DispatchDestination)
+
+					# At this point, the easy checks are done.  If we are still here, there was no
+					# match in the mapfile, and no rule provided a specific dispatch destination.
+					# So, use a set of heuristics, assuming a RESTfully structured URI, to figure
+					# out what should be done.
+					#
+					# The basic pattern that is expected is /component/method/arg1/arg2/argn
+					#
+					# On top of this basic pattern, there are some specific exceptions, based on
+					# the HTTP verb the request is using (GET, PUT, POST, DELETE), that
+					# deviate from that basic pattern.  These provide shortcuts for RESTful URLs,
+					# and are based in part on the RESTful Rails work.
+					#
+					# Method dispatch also supports the notion of dispatching to verb specific
+					# methods.  This is ultimately carried out in the Context object when an
+					# action is being invoked, however, as the target object must be interrogated
+					# to determine whether it has a method specific to the verb.
+					# 
+
+					dd = nil
+					request_uri = request.uri.sub(/\.\w+$/,C_empty)
+					#/component/method/arg1/arg2/argn
+					if request_uri =~ /^\/(\w+)\/(?:(\w+)((?:\/\w+)+)|([a-zA-Z]\w*)((?:\/\w+)*))$/
+						c = $1
+						m = $2 || $4
+						args = $3 || $5
+						args = args ? args[1..-1].to_s.split(C_slash) : []
+						dd = Iowa::DispatchDestination.new(c,m,args)
+					#/component/arg1/arg2/argn;method
+					#elsif request_uri =~ /^\/(\w+)((?:\/[\d\-a-f]+)+);(\w+)$/
+					elsif request_uri =~ /^\/(\w+)((?:\/[\w%]+)+);(\w+)$/
+						c = $1
+						m = $3
+						args = $2[1..-1].to_s.split(C_slash)
+						dd = Iowa::DispatchDestination.new(c,m,args)
+					else
+						request.request_method = request.params[C_method] if request.params[C_method]
+						rmeth = request.params[C_method] ? request.params[C_method].upcase : request.request_method.upcase
+						if rmeth == CGET or rmeth == CHEAD
+							if request_uri =~ /^\/(\w+)$/
+								dd = Iowa::DispatchDestination.new($1)
+							#elsif request_uri =~ /^\/(\w+)((?:\/[\d\-a-f]+)+)$/
+							elsif request_uri =~ /^\/(\w+)((?:\/[\w%]+)+)$/
+								c = $1
+								args = $2[1..-1].to_s.split(C_slash)
+								dd = Iowa::DispatchDestination.new(c,Cshow,args)
+							end
+						elsif rmeth == CPOST
+							if request_uri =~ /^\/(\w+)$/
+								dd = Iowa::DispatchDestination.new($1,Ccreate)
+							end
+						elsif rmeth == CPUT
+							#if request_uri =~ /^\/(\w+)((?:\/[\d\-a-f]+)+)$/
+							if request_uri =~ /^\/(\w+)((?:\/[\w%]+)+)$/
+								c = $1
+								args = $2[1..-1].to_s.split(C_slash)
+								dd = Iowa::DispatchDestination.new(c,Cupdate,args)
+							end
+						elsif rmeth == CDELETE
+							#if request_uri =~ /^\/(\w+)((?:\/[\d\-a-f]+)+)$/
+							if request_uri =~ /^\/(\w+)((?:\/[\w%]+)+)$/
+								c = $1
+								args = $2[1..-1].to_s.split(C_slash)
+								dd = Iowa::DispatchDestination.new(c,Cdestroy,args)
+							end
+						end
+					end
+					dd
+				end
+			end
+			
+# --------------------
+			
+			class RuleSet
+				def initialize(rule_struct)
+					@rules = []
+					if rule_struct.respond_to?(:[])
+						if rule_struct.respond_to?(:has_key?)
+							@rules << RewriteRule.new(rule_struct)
+						else
+							rule_struct.each {|rule| @rules << RewriteRule.new(rule)}
+						end
+					end
+				end
+
+				def process(request)
+					catch(:final) do
+						@rules.each {|rule| rule.process(request)}
+					end
+				end
+
+			end
+
+			class RewriteRule
+				def initialize(prearg = {:match => '',
+					:sub => nil,
+					:target => nil,
+					:gsub => nil,
+					:call => nil,
+					:eval => nil,
+					:branch => nil,
+					:dispatch => nil,
+					:final => false,
+					:cache => nil})
+					arg = Iowa::Hash.new
+					arg.step_merge!(prearg)
+					arg.symbolify_keys!
+
+					if arg[:cache]
+						@cache_size = arg[:cache].to_i > 0 ? arg[:cache].to_i : 100
+						self.cacheable = true
+					else
+						@cache_size = 100
+						self.cacheable = false
+					end
+
+					@final = arg[:final] ? true : false
+					if !arg[:match].is_a?(Regexp) and arg[:match] =~ /^\s*(\{|do).*(\}|end)\s*/m
+						instance_eval("@match = Proc.new #{arg[:match]}")
+					else
+						@match = arg[:match].is_a?(Regexp) ? arg[:match] : Regexp.new(arg[:match])
+					end
+
+					if arg[:target] =~ /^\s*(\{|do).*(\}|end)\s*/m
+						instance_eval("@target = Proc.new #{arg[:target]}")
+					else
+						@target = arg[:target]
+					end
+
+					@subtype = (arg[:gsub] && :gsub) || (arg[:sub] && :sub) || nil
+					rawsub = arg[:gsub] || arg[:sub]
+					if rawsub =~ /^\s*(\{|do).*(\}|end)\s*/m
+						instance_eval("@subproc = Proc.new #{rawsub}")
+						@subsub = nil
+					else
+						@subsub = rawsub
+						@subproc = nil
+					end
+
+					if arg[:eval]
+						ep = arg[:eval]
+						if ep !~ /^\s*(\{|do).*(\}|end)\s*/m
+							ep = "{|request| #{ep}}"
+						end
+						instance_eval("@evalproc = Proc.new #{ep}")
+					else
+						@evalproc = nil
+					end
+
+					@call = arg[:call]
+					@branch = arg[:branch] ? RuleSet.new(arg[:branch]) : nil
+					if arg[:dispatch] =~ /^\s*(\{|do).*(\}|end)\s*/m
+						instance_eval("@dispatch = Proc.new #{arg[:dispatch]}")
+						@final = true
+					elsif arg[:dispatch]
+						@dispatch = Iowa::DispatchDestination.new(arg[:dispatch])
+						@final = true
+					else
+						@dispatch = nil
+					end
+				end
+
+				def cacheable?
+					@cacheable
+				end
+
+				def cacheable=(val)
+					if val
+						@cache = Iowa::Caches::LRUCache(@cache_size)
+						@cacheable = true
+					else
+						@cache = nil
+						@cacheable = false
+					end
+				end
+
+				def component=(c)
+					if @destination
+						@destination.component = c
+					else
+						@destination = Iowa::DispatchDestination.new(c)
+					end
+				end
+
+				def component
+					@destination ? @destination.component : nil
+				end
+
+				def method=(m)
+					if @destination
+						@destination.method = m
+					else
+						@destination = Iowa::DispatchDestination.new(m)
+					end
+				end
+
+				def method
+					@destination ? @destination.method : nil
+				end
+
+				def args=(a)
+					if @destination
+						@destination.args = a
+					else
+						@destination = Iowa::DispatchDestination.new(a)
+					end
+				end
+
+				def args
+					@destination ? @destination.args : nil
+				end
+
+				def process(request)
+					do_branch = @branch
+					original_uri = request.uri
+					request.uri = ::String.new(request.uri) if request.uri.frozen?
+					@destination = nil
+					if @cacheable and @cache.include?(request.uri)
+						request.uri = @cache[request.uri]
+						do_branch = false
+					elsif (@match.is_a?(::Proc) ? @match.call(request) : @match.match(request.uri))
+						if @subtype
+							if @subsub
+								if @subtype == :sub
+									request.uri.sub!(@match,@subsub)
+								elsif @subtype == :gsub
+									request.uri.gsub!(@match,@subsub)
+								end
+							elsif @subproc
+								if @subtype == :sub
+									request.uri.sub!(@match) {|*args| @subproc.call(request,*args)}
+								elsif @subtype == :gsub
+									request.uri.gsub!(@match) {|*args| @subproc.call(request,*args)}
+								end
+							end
+						elsif @call
+							call_completed = false
+							if @call =~ /(?:::|^[A-Z][\w\d]*\.)/
+								@call.sub!(/^::/,'')
+								if @call =~ /::/
+									parts = @call.split(/::/).reject {|p| p == ''}
+								else
+									parts = @call.split('.',2)
+								end
+								meth = parts.pop
+								catch(:bad_const) do
+									klass = parts.inject(Object) do |o,n|
+										if o.const_defined? n
+											o.const_get n
+										else
+											throw :bad_const
+										end
+									end
+									throw :bad_const unless klass.existsKeyPath?(meth)
+									klass.valueForKeyPathWithArgs(meth,request)
+									call_completed = true
+								end
+							end
+							unless call_completed
+								::TOPLEVEL_BINDING.send(:valueForKeyPathWithArgs,@call,request)
+							end
+						elsif @evalproc
+							@evalproc.call(request)
+						end
+					
+						if do_branch and !@final
+							@branch.process(request)
+						end
+
+						@destination = @dispatch
+						@cache[original_uri] = request.uri if @cacheable
+
+						throw(:final,@destination) if @final
+					end
+
+					@destination
+				end
+			end
+		end
+	end
+end