og 0.5.0

data/lib/glue/logger.rb

@@ -0,0 +1,51 @@
+# = Logger
+#
+# A simple wrapper arround the Ruby logger. Mainly for compatibility
+# purposes.
+#
+# code:
+# * George Moschovitis  <gm@navel.gr>
+#
+# (c) 2004 Navel, all rights reserved.
+# $Id: logger.rb 161 2004-11-18 10:51:51Z gmosx $
+
+require "logger"
+
+# = Logger
+#
+# A simple wrapper arround the Ruby logger. Mainly for compatibility
+# purposes.
+#
+class Logger
+	alias_method :devel, :debug
+	alias_method :fine, :debug
+	
+	def detach
+	end
+	
+	# Used for debuging, remove this in release code.
+	#
+	def d(str)
+		self << "#{str}\n"
+	end
+
+	# Inspect an object. Used for debugging, remove this in release
+	# code.
+	#
+	def i(obj)
+		self << "Inspect #{obj.inspect()}\n"
+	end
+
+	private
+		
+	# the default Ruby logger has a hardwired silly format.
+	# we use some Ruby magic to fix it!
+	remove_const "Format"
+
+	Format = "%5s: %s\n"
+
+	def format_message(severity, timestamp, msg, progname)
+		Format % [severity, msg]
+	end
+end
+

data/lib/glue/macro.rb

@@ -0,0 +1,56 @@
+# = Macros
+#
+# A powerfull macro implementation for Ruby. Allows definition
+# of new macro.
+#
+# EXPERIMENTAL, not fully working yet
+#
+# code: 
+# George Moschovitis  <gm@navel.gr>
+#
+# (c) 2004 Navel, all rights reserved.
+# $Id: macro.rb 165 2004-11-18 12:04:04Z gmosx $
+
+$__macros__ = {}
+$__required__ = {}
+
+module Kernel
+
+alias_method :old_require, :require
+def require(path)
+	return if $__required__[path]
+	
+	source = File.read(path)
+	
+	# parse macro
+	source.gsub!(/defmacro\s*\/(.*?)\/\s(.*?)endmacro/m) {
+		$__macros__[Regexp.new($1)] = $2 ; ""
+	}
+	
+	# expand macros	
+	$__macros__.each { |match, replace|
+		source.gsub!(match, replace)
+	}
+	
+	$__required__[path] = true
+
+	eval(source)
+end
+
+end
+
+require "nitro/test1.rb"
+require "nitro/test2.rb"
+
+__END__
+
+Examples:
+
+defmacro /my_macro\((.*)\)/
+	begin 
+		my_function(\1)
+	rescue => ex
+		puts ex
+	end 
+endmacro
+

data/lib/glue/mixins.rb

@@ -0,0 +1,45 @@
+# = Mixins 
+#
+# A collection of useful mixins. Use these to synthesize your 
+# entities.
+#
+# code: 
+# * George Moschovitis  <gm@navel.gr>
+#
+# (c) 2004 Navel, all rights reserved.
+# $Id$
+
+module G;
+
+# = Expirable
+#
+# Generic expiring functionality mixin. 
+#
+module Expirable
+	attr_accessor :expires
+
+	# Set the expires timeout for this entry.
+
+	def expires_after(timeout = (60*60*24))
+		@expires = Time.now + timeout
+	end
+
+	# Set the expire timeout for this entry. The timeout happens
+	# after (base + rand(spread)) seconds.
+
+	def expires_spread(base, spread)
+		@expires = Time.now + base + rand(spread)
+	end
+
+	# Is this entry expired?
+
+	def expired?
+		if @expires.nil? or (Time.now > @expires)
+			return true
+		else
+			return false
+		end
+	end
+end
+
+end # module

data/lib/glue/number.rb

@@ -0,0 +1,30 @@
+# code:
+# * George Moschovitis  <gm@navel.gr>
+#
+# (c) 2004 Navel, all rights reserved.
+# $Id: number.rb 167 2004-11-23 14:03:10Z gmosx $
+
+module G;
+
+# = NumberUtils
+#
+# === Design:
+#
+# Implement as a module to avoid class polution. You can
+# still use Ruby's advanced features to include the module in your
+# class. Passing the object to act upon allows to check for nil,
+# which isn't possible if you use self.
+#
+module NumberUtils
+
+	# Returns the multiple ceil of a number
+	#
+	def self.ceil_multiple(num, multiple)
+		# gmosx: to_f is needed!s
+		# gmosx: IS THERE a more optimized way to do this?
+		return ((num.to_f/multiple).ceil*multiple)
+	end
+
+end
+
+end # module

data/lib/glue/pool.rb

@@ -0,0 +1,63 @@
+# code:
+# * George Moschovitis  <gm@navel.gr>
+#
+# (c) 2004 Navel, all rights reserved.
+# $Id: pool.rb 167 2004-11-23 14:03:10Z gmosx $
+
+require "thread"
+require "monitor"
+
+module G
+
+# = Pool
+#
+# Generalized object pool implementation. Implemented as a thread 
+# safe stack. Exclusive locking is needed both for push and pop. 
+#
+# INVESTIGATE: Could use the SizedQueue/Queue.
+#
+class Pool < Array
+	include MonitorMixin
+	
+	def initialize
+		super
+		@cv = new_cond()
+	end
+
+	# Add, restore an object to the pool.
+	#
+	def push(obj)
+		synchronize do
+			super
+			@cv.signal()
+		end
+	end
+	
+	# Obtain an object from the pool.
+	#
+	def pop
+		synchronize do
+			@cv.wait_while { empty? }
+			super
+		end
+	end
+
+	# Obtains an object, passes it to a block for processing
+	# and restores it to the pool.
+	def obtain
+		result = nil
+		
+		begin
+			obj = pop()
+
+			result = yield(obj)
+		ensure
+			push(obj)
+		end
+
+		return result
+	end
+	
+end
+
+end # module

data/lib/glue/property.rb

@@ -0,0 +1,301 @@
+# code:
+# * George Moschovitis  <gm@navel.gr>
+# design:
+# * Anastastios Koutoumanos  <ak@navel.gr>
+# * Elias Karakoulakis  <ekarak@ktismata.com>
+#
+# (c) 2004 Navel, all rights reserved.
+# $Id: property.rb 167 2004-11-23 14:03:10Z gmosx $
+
+require "glue/array"
+require "glue/hash"
+
+module G
+
+# = Property
+#
+# Ruby attributes are typeless and generally this is good. Some times
+# we need extra metadata though, for example in relational mapping,
+# or web form population.
+#
+# Only Fixnums, Strings, Floats, Times, Booleans are converted.
+#
+# The default = methods do not force the  types. A special 
+# __force_set method should be used instead.
+#
+#--
+# TODO:
+# Inject only the really needd methods into Module.
+# Perhaps a sync is needed in evals (!!!!)
+#++
+#
+class Property
+	# the symbol of the property
+	attr_accessor :symbol
+	# the string representation of the symbol
+	attr_accessor :name
+	# the class of the property
+	attr_accessor :klass
+	# additional metadata (like sql declaratio, sql index, etc)
+	attr_accessor :meta
+	
+	def initialize(symbol, klass, meta = {})
+		@symbol, @klass = symbol, klass
+		@meta = meta
+		@name = @symbol.to_s()
+	end
+	
+	def ==(other)
+		return @symbol == other.symbol
+	end
+end
+
+end # module
+
+class Module
+
+	# Define a property (== typed attribute)
+	# This works like Ruby's standard attr method, ie creates
+	# only one property. 
+	#
+	# Use the prop_reader, prop_writer, prop_accessor methods 
+	# for multiple properties.
+	#
+	# Examples:
+	#	prop String, :name, :sql => "char(32), :sql_index => "name(32)"
+	# --> creates only writer.
+	# prop Fixnum, :oid, writer = true, :sql => "integer PRIMARY KEY"
+	#	--> creates reader and writer.
+	# 
+	def prop(*params)
+		meta = {}
+		klass = Object
+		
+		for param in params
+			if param.is_a?(Class)
+				klass = param
+			elsif param.is_a?(Symbol)
+				symbol = param
+			elsif param.is_a?(TrueClass) or param.is_a?(TrueClass) 
+				writer = param
+			elsif param.is_a?(Hash)
+				# the meta hash.
+				meta = param
+			else
+				raise "Error when defining property!"
+			end
+		end
+
+		unless self.methods.include?("__props")
+			eval %{
+				# Properties
+				# An array is used to enforce order.
+				def __props
+					@__props
+				end
+
+				def __props=(props)
+					@__props = props
+				end
+				
+				def __meta
+					@__meta
+				end
+
+				def __meta=(meta)
+					@__meta = meta
+				end				
+			}
+		end
+
+		@__props = G::SafeArray.new() unless @__props
+				
+		property = G::Property.new(symbol, klass, meta)
+		
+		reader = meta[:reader] || true
+		writer = writer || meta[:writer] || false
+		
+		__add_prop(property, reader, writer)
+	end
+
+	# Helper method. Accepts a collection of symbols and generates
+	# properties. Only generates reader.
+	#
+	# Example:
+	#	prop_reader String, :name, :title, :body, :sql => "char(32)"
+	#
+	def prop_reader(*params)
+		meta = {}
+		klass = Object
+		symbols = []
+
+		for param in params
+			if param.is_a?(Class)
+				klass = param
+			elsif param.is_a?(Symbol)
+				symbols << param
+			elsif param.is_a?(Hash)
+				# the meta hash.
+				meta = param
+			else
+				raise "Error when defining property!"
+			end
+		end
+		
+		meta[:reader] = true
+		meta[:writer] = false
+		
+		for symbol in symbols
+			prop(klass, symbol, meta)
+		end
+	end
+
+	# Helper method. Accepts a collection of symbols and generates
+	# properties. Only generates writer.
+	#
+	# Example:
+	#	prop_writer String, :name, :title, :body, :sql => "char(32)"
+	#
+	def prop_writer(*params)
+		meta = {}
+		klass = Object
+		symbols = []
+
+		for param in params
+			if param.is_a?(Class)
+				klass = param
+			elsif param.is_a?(Symbol)
+				symbols << param
+			elsif param.is_a?(Hash)
+				# the meta hash.
+				meta = param
+			else
+				raise "Error when defining property!"
+			end
+		end
+		
+		meta[:reader] = false
+		meta[:writer] = true
+		
+		for symbol in symbols
+			prop(klass, symbol, meta)
+		end
+	end
+
+	# Helper method. Accepts a collection of symbols and generates
+	# properties. Generates reader and writer.
+	#
+	# Example:
+	#	prop_accessor String, :name, :title, :body, :sql => "char(32)"
+	#
+	def prop_accessor(*params)
+		meta = {}
+		klass = Object
+		symbols = []
+
+		for param in params
+			if param.is_a?(Class)
+				klass = param
+			elsif param.is_a?(Symbol)
+				symbols << param
+			elsif param.is_a?(Hash)
+				# the meta hash.
+				meta = param
+			else
+				raise "Error when defining property!"
+			end
+		end
+		
+		meta[:reader] = true
+		meta[:writer] = true
+		
+		for symbol in symbols
+			prop(klass, symbol, meta)
+		end
+	end
+	
+	# Add the property
+	#
+	def __add_prop(prop, reader = true, writer = true)
+		if idx = @__props.index(prop)
+			# override in case of duplicates. Keep the order of the props.
+			@__props[idx] = prop
+		else
+			@__props << prop
+		end
+		
+		# Precompile the property read/write methods
+
+		s, klass = prop.symbol, prop.klass 
+
+		if reader		
+			module_eval %{
+				def #{s}
+					return @#{s}
+				end
+			}
+		end
+			
+		if writer 
+			module_eval %{
+				def #{s}=(val)
+					@#{s} = val
+				end
+				
+				def __force_#{s}(val)
+						@#{s} = } + case klass.name
+													when Fixnum.name
+														"val.to_i()"
+													when String.name
+														"val.to_s()"
+													when Float.name
+														"val.to_f()"
+													when Time.name
+														"Time.parse(val.to_s())"
+													when TrueClass.name, FalseClass.name
+														"val.to_i() > 0"
+													else
+														"val"
+												end + %{ 
+				end
+			}
+		end
+	end
+	
+	# Attach metadata 
+	#
+	def meta(key, val)
+		@__meta = G::SafeHash.new unless @__meta
+
+		@__meta[key] = [] unless @__meta[key]
+
+		# guard against duplicates, no need to keep order.
+		@__meta[key].delete_if { |v| val == v }
+		@__meta[key] << val			
+	end
+	
+	# This method is typically called before including other
+	# modules to preserve properties order. 
+	#
+	def inherit_meta(mod = superclass)
+		# concat props.
+		if mod.__props
+			@__props = G::SafeArray.new unless @__props
+			
+			mod.__props.each { |p|
+				__add_prop(p)
+			} 
+		end
+
+		# concat metadata
+		if mod.__meta
+			mod.__meta.each { |k, val|
+				val.each { |v|
+					meta(k, v)
+				} if val
+			}
+		end
+	end
+	
+end
+