glue 0.0.1 → 0.13.0

data/lib/glue/attribute.rb

@@ -0,0 +1,83 @@
+# * George Moschovitis  <gm@navel.gr>
+# Original code from Rails distribution.
+# http://www.rubyonrails.com
+# $Id$
+
+#--
+# Extends the module object with module and instance accessors 
+# for class attributes, just like the native attr* accessors for 
+# instance attributes. Aliases for classes are also provided.
+#
+# Example:
+#
+# mattr_accessor :my_attr, 'Default value'
+#++
+class Module # :nodoc:
+	
+  def mattr_reader(*params)
+		default = if params.last.is_a?(Symbol) then nil else params.pop end
+		
+		
+    for sym in params
+			module_eval <<-"end_eval", __FILE__, __LINE__
+			
+        if not defined?(@@#{sym.id2name})
+          @@#{sym.id2name} = #{default.inspect}
+        end
+        
+        def self.#{sym.id2name}
+          @@#{sym}
+        end
+
+        def #{sym.id2name}
+          @@#{sym}
+        end
+
+        def call_#{sym.id2name}
+          case @@#{sym.id2name}
+            when Symbol then send(@@#{sym})
+            when Proc   then @@#{sym}.call(self)
+            when String then @@#{sym}
+            else nil
+          end
+        end
+				
+      end_eval
+    end
+  end
+  alias_method :cattr_reader, :mattr_reader
+  
+  def mattr_writer(*params)
+		default = if params.last.is_a?(Symbol) then nil else params.pop end
+		
+    for sym in params
+			module_eval <<-"end_eval", __FILE__, __LINE__
+
+        if not defined?(@@#{sym.id2name})
+          @@#{sym.id2name} = #{default.inspect.inspect}
+        end
+        
+        def self.#{sym.id2name}=(obj)
+          @@#{sym.id2name} = obj
+        end
+
+        def self.set_#{sym.id2name}(obj)
+          @@#{sym.id2name} = obj
+        end
+
+        def #{sym.id2name}=(obj)
+          @@#{sym} = obj
+        end
+
+      end_eval
+    end
+  end
+  alias_method :cattr_writer, :cattr_writer
+  
+  def mattr_accessor(*syms)
+    mattr_reader(*syms)
+    mattr_writer(*syms)
+  end
+  alias_method :cattr_accessor, :mattr_accessor
+	
+end

data/lib/glue/cache.rb

@@ -0,0 +1,138 @@
+# * George Moschovitis  <gm@navel.gr>
+# * Anastasios Koutoumanos  <ak@navel.gr>
+# (c) 2004-2005 Navel, all rights reserved.
+# $Id: cache.rb 282 2005-03-10 12:24:53Z gmosx $
+
+module N
+
+# A cache utilizing a simple LRU (Least Recently Used) policy.
+# The items managed by this cache must respond to the #key method.
+# Attempts to optimize reads rather than inserts!
+#
+# LRU semantics are enforced by inserting the items in a queue.
+# The lru item is always at the tail. Two special sentinels
+# (head, tail) are used to simplify (?) the code.
+
+class LRUCache < Hash
+
+	# Mix this in your class to make LRU-managable.
+	
+	module Item
+		attr_accessor :lru_key, :lru_prev, :lru_next
+	end
+
+	# head-tail sentinels
+	
+	class Sentinel; include Item; end
+
+	# the maximum number of items in the cache.
+
+	attr_accessor :max_items
+
+	# the head sentinel
+	
+	attr :head
+
+	# the tail sentinel, tail.prev points to the lru item.
+
+	attr :tail
+
+	def initialize(max_items)
+		@max_items = max_items
+		lru_clear()
+	end
+
+	# Lookup an item in the cache.
+	
+	def [](key)
+		if item = super
+			return lru_touch(item)
+		end
+	end
+
+	# The inserted item is considered mru!
+	
+	def []=(key, item)
+		item = super
+		item.lru_key = key
+		lru_insert(item)
+	end
+
+	# Delete an item from the cache.
+	
+	def delete(key)
+		if item = super
+			lru_delete(item)
+		end
+	end
+
+	# Clear the cache.
+	
+	def clear
+		super
+		lru_clear()
+	end
+
+	# The first (mru) element in the cache.
+	
+	def first
+		@head.lru_next
+	end
+
+	# The last (lru) element in the cache.
+	
+	def last
+		@tail.lru_prev
+	end
+	alias_method :lru, :last
+
+	private
+
+	# Delete an item from the lru list.
+	
+	def lru_delete(item)
+		lru_join(item.lru_prev, item.lru_next)
+		return item
+	end
+
+	# Join two items in the lru list.
+	# Return y to allow for chaining.
+	
+	def lru_join(x, y)
+		x.lru_next = y
+		y.lru_prev = x
+		return y
+	end
+
+	# Append a child item to a parent item in the lru list
+	# (Re)inserts the child in the list.
+	
+	def lru_append(parent, child)
+		lru_join(child, parent.lru_next)
+		lru_join(parent, child)
+	end
+
+	# Insert an item
+
+	def lru_insert(item)
+		delete(last.lru_key) if size() > @max_items
+		lru_append(@head, item)
+	end
+	
+	# Touch an item, make mru!
+	# Returns the item.
+	
+	def lru_touch(item)
+		lru_append(@head, lru_delete(item))
+	end
+	
+	# Clear the lru.
+	
+	def lru_clear
+		@head = Sentinel.new
+		@tail = Sentinel.new
+		lru_join(@head, @tail)
+	end	
+end
+
+end 

data/lib/glue/flexob.rb

@@ -0,0 +1,12 @@
+# * George Moschovitis  <gm@navel.gr>
+# (c) 2004-2005 Navel, all rights reserved.
+# $Id$
+
+require 'ostruct'
+
+# A flexible Object.
+# Temporarily implemented as a simple OpenStruct.
+
+class Flexob < OpenStruct
+
+end

data/lib/glue/hash.rb

@@ -0,0 +1,122 @@
+# * George Moschovitis  <gm@navel.gr>
+# (c) 2004-2005 Navel, all rights reserved.
+# $Id: hash.rb 282 2005-03-10 12:24:53Z gmosx $
+
+require 'sync'
+
+module N
+
+# A thread-safe hash. We use a sync object instead of a mutex,
+# because it is re-entrant. An exclusive lock is needed when 
+# writing, a shared lock IS NEEDED when reading
+# uses the delegator pattern to allow for multiple
+# implementations!
+
+class SafeHash < Hash
+	attr :sync
+
+	# gmosx: delegator is not used.
+	#
+	def initialize(delegator = nil)
+		@sync = ::Sync.new
+	end
+
+	def [](key)
+		@sync.synchronize(::Sync::SH) { super }
+	end
+
+	def []=(key, value)
+		@sync.synchronize(::Sync::EX) { super }
+	end
+
+	def delete(key)
+		@sync.synchronize(::Sync::EX) { super }
+	end
+
+	def clear
+		@sync.synchronize(::Sync::EX) {	super }
+	end
+
+	def size
+		@sync.synchronize(::Sync::SH) {	super }
+	end
+
+	def values
+		@sync.synchronize(::Sync::SH) { super }
+	end
+
+	def keys
+		@sync.synchronize(::Sync::SH) { super }
+	end
+
+end 
+
+# A thread-safe hash. We use a sync object instead of a mutex,
+# because it is re-entrant. An exclusive lock is needed when 
+# writing, a shared lock IS NEEDED when reading.
+#
+# === Design
+#
+# This class uses the delegator pattern. However we dont use rubys
+# delegation facilities, they are more general and powerfull than we
+# need here (and slower). Instead a custom (but simple) solution is
+# used.
+#
+# === Example
+#
+# hash = SafeHashDelegator.new(Hash.new)
+# hash = SafeHashDelegator.new(Hash.new)
+
+class SafeHashDelegator < Hash
+	attr :delegate, :sync
+
+	def initialize(delegate)
+		@delegate = delegate
+		@sync = ::Sync.new
+	end
+
+	def [](key)
+		@sync.synchronize(::Sync::SH) {
+			@delegate[key]
+		}
+  end
+
+  def []=(key, value)
+		@sync.synchronize(::Sync::EX) {
+			@delegate[key] = value
+		}
+  end
+
+	def delete(key)
+		@sync.synchronize(::Sync::EX) {
+			@delegate.delete(key)
+		}
+	end
+
+	def clear
+		@sync.synchronize(::Sync::EX) {
+			@delegate.clear
+		}
+	end
+
+	def size
+		@sync.synchronize(::Sync::SH) {
+			@delegate.size()
+		}
+	end
+
+	def values
+		@sync.synchronize(::Sync::SH) {
+			@delegate.values()
+		}
+	end
+
+	def keys
+		@sync.synchronize(::Sync::SH) {
+			@delegate.keys()
+		}
+	end
+
+end
+
+end 

data/lib/glue/inflector.rb

@@ -0,0 +1,91 @@
+# Code from RubyOnRails (http://www.rubyonrails.com)
+# Copyright (c) 2004 David Heinemeier Hansson.
+
+module N
+
+# The Inflector transforms words from singular to plural, 
+# class names to table names, modulized class names to ones without,
+# and class names to foreign keys.
+
+module Inflector 
+  extend self
+
+  def pluralize(word)
+    result = word.dup
+    plural_rules.each do |(rule, replacement)|
+      break if result.gsub!(rule, replacement)
+    end
+    return result
+  end
+
+  def singularize(word)
+    result = word.dup
+    singular_rules.each do |(rule, replacement)|
+      break if result.gsub!(rule, replacement)
+    end
+    return result
+  end
+
+  def camelize(lower_case_and_underscored_word)
+    lower_case_and_underscored_word.gsub(/(^|_)(.)/){$2.upcase}
+  end
+  
+  def underscore(camel_cased_word)
+    camel_cased_word.gsub(/([A-Z]+)([A-Z])/,'\1_\2').gsub(/([a-z])([A-Z])/,'\1_\2').downcase
+  end
+
+  def demodulize(class_name_in_module)
+    class_name_in_module.gsub(/^.*::/, '')
+  end
+
+  def foreign_key(class_name, separate_class_name_and_id_with_underscore = true)
+    Inflector.underscore(Inflector.demodulize(class_name)) + 
+      (separate_class_name_and_id_with_underscore ? "_id" : "id")
+  end
+  
+	# Convert a class to a name.
+	
+	def name(klass)
+		Inflector.underscore(Inflector.demodulize(klass.to_s))
+	end
+	
+	# Convert a class to a name in plural
+	
+	def plural_name(klass)
+		Inflector.pluralize(Inflector.underscore(Inflector.demodulize(klass.to_s)))
+	end
+	
+  private
+    def plural_rules #:doc:
+      [
+        [/(x|ch|ss)$/, '\1es'],               # search, switch, fix, box, process, address
+        [/([^aeiouy]|qu)y$/, '\1ies'],        # query, ability, agency
+        [/(?:([^f])fe|([lr])f)$/, '\1\2ves'], # half, safe, wife
+        [/sis$/, 'ses'],                      # basis, diagnosis
+        [/([ti])um$/, '\1a'],                 # datum, medium
+        [/person$/, 'people'],                # person, salesperson
+        [/man$/, 'men'],                      # man, woman, spokesman
+        [/child$/, 'children'],               # child
+        [/s$/, 's'],                          # no change (compatibility)
+        [/$/, 's']
+      ]
+    end
+
+    def singular_rules #:doc:
+      [
+          [/(x|ch|ss)es$/, '\1'],
+          [/([^aeiouy]|qu)ies$/, '\1y'],
+          [/([lr])ves$/, '\1f'],
+          [/([^f])ves$/, '\1fe'],
+          [/(analy|ba|diagno|parenthe|progno|synop|the)ses$/, '\1sis'],
+          [/([ti])a$/, '\1um'],
+          [/people$/, 'person'],
+          [/men$/, 'man'],
+          [/status$/, 'status'],
+          [/children$/, 'child'],
+          [/s$/, '']
+        ]
+    end
+end
+
+end