IOWA 1.0.0

data/microprojects/LRUCache/external/test_support.rb

@@ -0,0 +1,8 @@
+module IWATestSupport
+
+	def self.cd_to_test_dir(dir)
+		Dir.chdir(File.dirname(File.expand_path(dir)))
+	end
+
+end
+

data/microprojects/LRUCache/setup.rb

@@ -0,0 +1,22 @@
+#!ruby
+
+basedir = File.dirname(__FILE__)
+$:.push(basedir)
+
+require 'external/package'
+require 'rbconfig'
+begin
+	require 'rubygems'
+rescue LoadError
+end
+
+Dir.chdir(basedir)
+Package.setup("1.0") {
+	name "Iowa::Caches::LRUCache"
+
+	translate(:lib, 'src/' => '')
+	lib *Dir["src/iowa/**/*.rb"]
+	ri *Dir["src/iowa/**/*.rb"]
+
+	unit_test ["test/TC_LRUCache.rb"]
+}

data/microprojects/LRUCache/src/iowa/Association.rb

@@ -0,0 +1,57 @@
+module Iowa
+	class Association
+	
+		def initialize(association)
+			@association = association
+		end
+
+		def association
+			@association
+		end
+
+		def test(object)
+			true
+		end
+	end
+
+	class PathAssociation < Association
+		def get(object,cache = false)
+			myval = object.cached_associations[@association]
+			if cache
+				usecache = true
+				usecache = false unless myval
+				if myval.respond_to?(:empty?)
+					usecache = false if myval.empty?
+				end
+			end
+			if cache and usecache
+				myval
+			else
+				object.cached_associations[@association] = object.valueForKeyPath(@association)
+			end
+		end
+	
+		def set(object, val)
+			object.takeValueForKeyPath(val, @association)
+		end
+
+		def test(object)
+			object.existsKeyPath?(@association)
+		end
+	end
+
+	class LiteralAssociation < Association
+
+		def get(object = nil, cache = false)
+			unless @association.is_a?(Proc)
+				@association
+			else
+				@association.call(object.send(:binding))
+			end
+		end
+	
+		def set(object, val)
+			@association = val
+		end
+	end
+end

data/microprojects/LRUCache/src/iowa/Constants.rb

@@ -0,0 +1,159 @@
+require 'iowa/Association'
+require 'singleton'
+
+module Iowa
+
+	class UnknownValue
+		include Singleton
+		def to_s
+			'UNK'
+		end
+	end
+	alias :to_str :to_s
+
+	BindingKeywords = {'action' => [LiteralAssociation,true],
+		'id' => [LiteralAssociation, false],
+		'item' => [PathAssociation,true],
+		'list' => [PathAssociation,true],
+		'key' => [PathAssociation,true],
+		'klass' => [LiteralAssociation,true], # not 'class' because of HTML conflict
+		'tag' => [LiteralAssociation,true],
+		'condition' => [PathAssociation,true],
+		'value' => [PathAssociation,true]}
+
+	ClassSeparator = '::'.freeze
+	ContentClassesNamespace = 'Iowa::Application::ContentClasses'.freeze
+
+	C_empty = ''.freeze
+	C_ = ' '.freeze
+	C_anon_ = '_anon_'.freeze
+	C_at = '@'.freeze
+	C_atat = '@@'.freeze
+	C_bnd = '.bnd'.freeze
+	C_content = '_content'.freeze
+	C_default = '_default'.freeze
+	C_dot = '.'.freeze
+	C_dotdot = '..'.freeze
+	C_equal = '='.freeze
+	C_gt = '>'.freeze
+	C_item = '_item'.freeze
+	C_iwa = '.iwa'.freeze
+	C_list = '_list'.freeze
+	C_method = '_method'.freeze
+	C_semicolon = ';'.freeze
+	C_slash = '/'.freeze
+	C0 = '0'.freeze
+	C_0to7 = 0..7.freeze
+	C1 = '1'.freeze
+	Caction = 'action'.freeze
+	Caddresses = 'addresses'.freeze
+	Capplication = 'application'.freeze
+	Capplication_data = 'application/data'.freeze
+	Cbasedir = 'basedir'.freeze
+	Cbaselog = 'baselog'.freeze
+	Cbasename = 'basename'.freeze
+	Cbody = 'body'.freeze
+	CBodyContent = 'BodyContent'.freeze
+	Cbrowsers = 'browsers'.freeze
+	Cbutton = 'button'.freeze
+	Ccacheable = 'cacheable'.freeze
+	Ccheckbox = 'checkbox'.freeze
+	Cchecked = 'checked'.freeze
+	Cchecksum = 'checksum'.freeze
+	CClass = 'Class'.freeze
+	Cclass = 'class'.freeze
+	Ccondition = 'condition'.freeze
+	CContentClasses = 'ContentClasses'.freeze
+	CCookie = 'Cookie'.freeze
+	Ccookie = 'cookie'.freeze
+	Cdaemonize = 'daemonize'.freeze
+	Cdatabase = 'database'.freeze
+	Cdefault = 'default'.freeze
+	Cdepth = 'depth'.freeze
+	Cdirectory = 'directory'.freeze
+	Cdispatcher = 'dispatcher'.freeze
+	Cdoc_root = 'doc_root'.freeze
+	Cdocroot = 'docroot'.freeze
+	CdynamicString = 'dynamicString'.freeze
+	Celement = 'element'.freeze
+	Cexceptions = 'exceptions'.freeze
+	Cfalse = 'false'.freeze
+	CFALSE = 'false'.freeze
+	Cfilename = 'filename'.freeze
+	Cfiles = 'files'.freeze
+	Cforce = 'force'.freeze
+	CEIN = 'EIN'.freeze
+	CHash = 'Hash'.freeze
+	Cheight = 'height'.freeze
+	Chostname = 'hostname'.freeze
+	Chosts = 'hosts'.freeze
+	Chref = 'href'.freeze
+	Cid = 'id'.freeze
+	Cimage = 'image'.freeze
+	Cimage_path = 'image_path'.freeze
+	Cinterval = 'interval'.freeze
+	Ciowa_log = 'iowa_log'.freeze
+	Ciowa_root = 'iowa_root'.freeze
+	Cips = 'ips'.freeze
+	Citem = 'item'.freeze
+	Ckey = 'key'.freeze
+	Cklass = 'klass'.freeze
+	Clabel = 'label'.freeze
+	Clast_modification = 'last_modification'.freeze
+	Clibrary = 'library'.freeze
+	Clink = 'link'.freeze
+	Clist = 'list'.freeze
+	CLocation = 'Location'.freeze
+	Clog_root = 'log_root'.freeze
+	Clogging = 'logging'.freeze
+	Clonely_tag_terminator = ' />'.freeze
+	CMain = 'Main'.freeze
+	Cmapfile = 'mapfile'.freeze
+	Cmaxage = 'maxage'.freeze
+	Cmaxsize = 'maxsize'.freeze
+	Cmethod = 'method'.freeze
+	Cminlevel = 'minlevel'.freeze
+	Cmodel = 'model'.freeze
+	Cmultiple = 'multiple'.freeze
+	Cname = 'name'.freeze
+	COK = 'OK'.freeze
+	Cpage = 'page'.freeze
+	Cpagecache = 'pagecache'.freeze
+	Cparams = 'params'.freeze
+	Cpath = 'path'.freeze
+	Cpolicy = 'policy'.freeze
+	Cport = 'port'.freeze
+	Cplural = 'plural'.freeze
+	Cpost = 'post'.freeze
+	Cradio = 'radio'.freeze
+	Crefresh = 'refresh'.freeze
+	Crequest_cacheable = 'request_cacheable'.freeze
+	Croot_path = 'root_path'.freeze
+	Croot_url = 'root_url'.freeze
+	Cscreens = 'screens'.freeze
+	Cselected = 'selected'.freeze
+	Cserialize_templates = 'serialize_templates'.freeze
+	Csession = 'session'.freeze
+	Csessioncache = 'sessioncache'.freeze
+	Csingular = 'singular'.freeze
+	Csocket = 'socket'.freeze
+	Csrc = 'src'.freeze
+	Csubmit = 'submit'.freeze
+	Ctagclass = 'tagclass'.freeze
+	Ctag = 'tag'.freeze
+	CtemplateRoot = 'templateRoot'.freeze
+	Ctext_html = 'text/html'.freeze
+	Ctext_javascript = 'text/javascript'.freeze
+	Ctitle = 'title'.freeze
+	Ctrue = 'true'.freeze
+	CTRUE = 'TRUE'.freeze
+	Cttl = 'ttl'.freeze
+	Ctype = 'type'.freeze
+	Cuse_lockfile = 'use_lockfile'.freeze
+	CUserAgent = 'User-Agent'.freeze
+	Cvalue = 'value'.freeze
+	Cvariation = 'variation'.freeze
+	Cwebrick = 'webrick'.freeze
+	Cwidth = 'width'.freeze
+
+end

data/microprojects/LRUCache/src/iowa/Hash.rb

@@ -0,0 +1,63 @@
+module Iowa
+
+	# This is a subclass of Ruby's Hash that implements a few convenient
+	# methods used by IOWA.
+	
+	class Hash < Hash
+
+		# A simple little routine to downcase any String used as a key
+		# in a hash or any hash nested as value somewhere within the hash.
+		# Thanks to Daniel Berger for this implementation.
+
+		def downcase_keys!
+			upper = /A-Z/
+			self.each do |k,v|
+				next unless k.kind_of? String
+				self[k.dup.downcase] = v
+				self.delete(k) if upper.match(k)
+			end
+		end
+
+		# Convert any symbolic keys to strings.
+		
+		def stringify_keys!
+			self.each do |k,v|
+				next if k.kind_of? String
+				self[k.to_s] = v
+				self.delete k
+			end
+		end
+		
+		def step_merge!(h)
+			h.each do |k,v|
+				if v.kind_of?(::Hash)
+					if self[k].kind_of?(::Hash)
+						unless self[k].respond_to?(:step_merge!)
+							if dp = self[k].default_proc
+								self[k] = Iowa::Hash.new {|h,k| dp.call(h,k)}.step_merge!(self[k])
+							else
+								osk = self[k]
+								self[k] = Iowa::Hash.new
+								self[k].step_merge!(osk)
+							end
+						end
+						self[k].step_merge!(v)
+					else
+						if self.default_proc
+							self.delete k
+							self[k]
+						end
+						unless self[k].kind_of?(::Hash)
+							self.delete k
+							self[k] = Iowa::Hash.new
+						end
+						self[k].step_merge!(v)
+					end
+				else
+					self[k] = v
+				end
+			end
+		end
+
+	end
+end

data/microprojects/LRUCache/src/iowa/Mutex.rb

@@ -0,0 +1,129 @@
+module Iowa
+
+	# Iowa::Mutex is a slight modification of the standard Ruby Mutex class.
+	# This class changes the array operations used to manage the queue of
+	# threads waiting for a lock in order to get better memory management
+	# behavior from the array.  This mutex will also not block if the thread
+	# holding a lock on a mutex calls lock on that mutex again.  If nested
+	# locking occurs, the locks must be matched by an equal number of unlocks
+	# before the mutex will actually be unlocked.
+
+	class Mutex
+		
+		# Creates a new Mutex.
+		
+		def initialize
+			@waiting = []
+			@locked = false;
+			@nested_locks = 0
+			@waiting.taint		# enable tainted comunication
+			self.taint
+		end
+
+		
+		# Returns the thread that holds the lock or +false+ if the mutex is not locked.
+		
+		def locked?
+			@locked
+		end
+
+		
+		# Attempts to obtain the lock and returns immediately. Returns +true+ if the
+		# lock was granted.
+		
+		def try_lock
+			@nested_locks += 1 and return true if @locked == Thread.current
+			result = false
+			Thread.critical = true
+			unless @locked
+				@locked = Thread.current
+				result = true
+			end
+			Thread.critical = false
+			result
+		end
+
+
+		# Attempts to obtain a lock on the mutex.  Block if a lock can not be
+		# obtained immediately and waits until the lock can be obtained.
+		# If this thread already holds this lock, returns immediately.
+		# Returns the mutex.
+
+		def lock
+			if @locked == Thread.current
+				@nested_locks += 1
+			else
+				while (Thread.critical = true; @locked)
+					@waiting.unshift Thread.current
+					Thread.stop
+				end
+				@locked = Thread.current
+				Thread.critical = false
+			end
+			self
+		end
+
+
+		# Releases this thread's lock on the mutex and wakes the next thread
+		# waiting for the lock, if any.
+		
+		def unlock
+			return unless @locked
+			if @nested_locks > 0
+				@nested_locks -= 1
+			else
+				Thread.critical = true
+				@locked = false
+				begin
+					t = @waiting.pop
+					t.wakeup if t
+				rescue ThreadError
+					retry
+				end
+				Thread.critical = false
+				begin
+					t.run if t
+				rescue ThreadError
+				end
+			end
+			self
+		end
+
+		
+		# If the mutex is locked, unlocks the mutex, wakes one waiting thread, and
+		# yields in a critical section.
+		
+		def exclusive_unlock
+			return unless @locked
+			if @nested_locks > 0
+				@nested_locks -= 1
+			else
+				Thread.exclusive do
+					@locked = false
+					begin
+						t = @waiting.pop
+						t.wakeup if t
+					rescue ThreadError
+						retry
+					end
+					yield
+				end
+			end
+			self
+		end
+
+  
+		# Obtains a lock, runs the block, and releases the lock when the block
+		# completes.  See the example under Mutex.
+  
+		def synchronize
+			lock
+			begin
+				yield
+			ensure
+				unlock
+			end
+ 		end
+
+	end
+end

data/microprojects/LRUCache/src/iowa/caches/LRUCache.rb

@@ -0,0 +1,287 @@
+require 'enumerator'
+require 'iowa/Mutex'
+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 = Iowa::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
+
+			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
+			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
+			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
+			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).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