nitro 0.12.0 → 0.13.0

data/lib/glue.rb

@@ -1,55 +0,0 @@
-# General libraries used by various projects.
-#
-#-- 
-# George Moschovitis  <gm@navel.gr>
-# (c) 2004-2005 Navel, all rights reserved.
-# $Id: glue.rb 215 2005-01-24 10:44:05Z gmosx $
-#++
-
-require 'English'
-require 'pp'
-
-require 'glue/property'
-require 'glue/attribute'
-
-# The standard namespace module.
-
-module N; end
-
-class NilClass
-
-	# quite usefull for error tolerant apps.
-	# a bit dangerous? Will have to rethink this.
-	
-	def empty?
-		return true
-	end
-end
-
-class Class
-	#--
-	# gmosx: is this really needed?
-	#++
-	
-	def to_i
-		return self.hash
-	end
-end
-
-module Kernel
-
-	# Pretty prints an exception/error object
-	# usefull for helpfull debug messages
-	#
-	# Input:
-	# The Exception/StandardError object
-	#
-	# Output:
-	# the pretty printed string
-	
-	def pp_exception(ex)
-		return %{#{ex.message}\n\tBACKTRACE:\n\t#{ex.backtrace.join("\n\t")}\n\tLOGGED FROM:\n\t#{caller[0]}}
-	end
-
-end
-

data/lib/glue/array.rb

@@ -1,61 +0,0 @@
-# * George Moschovitis  <gm@navel.gr>
-# (c) 2002-2005 Navel, all rights reserved.
-# $Id: array.rb 266 2005-02-28 14:50:48Z gmosx $
-
-require 'sync'
-
-module N
-
-# A thread-safe array. 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.
-
-class SafeArray < Array
-	
-	attr :sync
-
-	# gmosx: delegator is not used.
-	
-	def initialize(delegator = nil)
-		@sync = Sync.new()
-	end
-
-	def << (value)
-		return @sync.synchronize(Sync::SH) { super }		
-	end
-	
-	def delete_if(&block) 
-		return @sync.synchronize(Sync::SH) { super }				
-	end
-	
-	def [](key)
-		return @sync.synchronize(Sync::SH) { super }
-	end
-
-	def []=(key, value)
-		return @sync.synchronize(Sync::EX) { super }
-	end
-
-	def delete(key)
-		return @sync.synchronize(Sync::EX) { super }
-	end
-
-	def clear
-		@sync.synchronize(Sync::EX) {	super }
-	end
-
-	def size
-		return @sync.synchronize(Sync::SH) { super }
-	end
-
-	def shift
-		return @sync.synchronize(::Sync::EX) { super }
-	end
-
-	def unshift(el)
-		return @sync.synchronize(::Sync::EX) { super }
-	end
-		
-end
-
-end 

data/lib/glue/attribute.rb

@@ -1,83 +0,0 @@
-# * 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

@@ -1,138 +0,0 @@
-# * George Moschovitis  <gm@navel.gr>
-# * Anastasios Koutoumanos  <ak@navel.gr>
-# (c) 2004-2005 Navel, all rights reserved.
-# $Id: cache.rb 249 2005-02-04 14:03:00Z 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

@@ -1,12 +0,0 @@
-# * 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

@@ -1,122 +0,0 @@
-# * George Moschovitis  <gm@navel.gr>
-# (c) 2004-2005 Navel, all rights reserved.
-# $Id: hash.rb 263 2005-02-23 13:45:08Z 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