glue 0.0.1 → 0.13.0

data/lib/glue/logger.rb

@@ -0,0 +1,147 @@
+# * George Moschovitis  <gm@navel.gr>
+# (c) 2004-2005 Navel, all rights reserved.
+# $Id: logger.rb 282 2005-03-10 12:24:53Z gmosx $
+
+require 'logger'
+
+# A simple wrapper arround the Ruby logger. Mainly for 
+# compatibility purposes.
+
+class Logger
+	alias_method :devel, :debug
+	alias_method :fine, :debug
+	
+	# Prints a trace message to DEBUGLOG (at debug level).  
+	# Useful for emitting the value of variables, etc.  Use 
+	# like this:
+	#
+	#   x = y = 5
+	#   trace 'x'        # -> 'x = 5'
+	#   trace 'x ** y'   # -> 'x ** y = 3125'
+	#
+	# If you have a more complicated value, like an array of 
+	# hashes, then you'll probably want to use an alternative 
+	# output format.  For instance:
+	#
+	#   trace 'value', :yaml
+	#
+	# Valid output format values (the _style_ parameter) are:
+	#
+	#   :p :inspect
+	#   :pp                     (pretty-print, using 'pp' library)
+	#   :s :to_s
+	#   :y :yaml :to_yaml       (using the 'yaml' library')
+	#
+	# The default is <tt>:p</tt>.
+	#
+	# CREDITS:
+	# 
+	# This code comes straight from the dev-utils Gem.
+	# Author: Gavin Sinclair <gsinclair@soyabean.com.au>
+	
+  def trace(expr, style=:p)
+    unless expr.respond_to? :to_str
+      warn "trace: Can't evaluate the given value: #{caller.first}"
+    else
+			require 'extensions/binding'
+
+      Binding.of_caller do |b|
+        value = b.eval(expr.to_str)
+        formatter = TRACE_STYLES[style] || :inspect
+        case formatter
+        when :pp then require 'pp'
+        when :y, :yaml, :to_yaml then require 'yaml'
+        end
+        value_s = value.send(formatter)
+        message = "#{expr} = #{value_s}"
+        lines = message.split(/\n/)
+        indent = "   "
+        debug(lines.shift)            					
+        lines.each do |line|
+          debug(indent + line)
+        end
+      end
+    end
+  end
+  TRACE_STYLES = {}  # :nodoc:
+  TRACE_STYLES.update( :pp => :pp_s, :s => :to_s, :p => :inspect, :y => :to_yaml,
+                       :yaml => :to_yaml, :inspect => :inspect, :to_yaml => :to_yaml )
+
+	# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+	# Global logger interface. 
+	# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+	# Override the logger with your custom version.
+	#
+	@@global_logger = Logger.new(STDERR)
+
+	def self.set(logger)
+		@@global_logger = logger
+	end
+
+	def self.get
+		@@global_logger
+	end
+	
+	def self.warn(str)
+		@@global_logger.warn(str)
+	end
+
+	def self.info(str)
+		@@global_logger.info(str)
+	end
+
+	def self.debug(str)
+		@@global_logger.debug(str)
+	end
+	
+	def self.error(str)
+		@@global_logger.error(str)
+	end
+
+	#--
+	# Saddly have to duplicate the code to make
+	# Binding.of_caller work.
+	#++
+  def self.trace(expr, style=:p)
+    unless expr.respond_to? :to_str
+      warn "trace: Can't evaluate the given value: #{caller.first}"
+    else
+			require 'extensions/binding'
+
+      Binding.of_caller do |b|
+        value = b.eval(expr.to_str)
+        formatter = TRACE_STYLES[style] || :inspect
+        case formatter
+        when :pp then require 'pp'
+        when :y, :yaml, :to_yaml then require 'yaml'
+        end
+        value_s = value.send(formatter)
+        message = "#{expr} = #{value_s}"
+        lines = message.split(/\n/)
+        indent = "   "
+        debug(lines.shift)            					
+        lines.each do |line|
+          debug(indent + line)
+        end
+      end
+    end
+  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/misc.rb

@@ -0,0 +1,14 @@
+# * George Moschovitis  <gm@navel.gr>
+# (c) 2004-2005 Navel, all rights reserved.
+# $Id$
+
+# Executes a Ruby block without warnings.
+
+def silence_warnings
+	old_verbose, $VERBOSE = $VERBOSE, nil
+	begin
+		yield
+	ensure
+		$VERBOSE = old_verbose
+	end
+end

data/lib/glue/mixins.rb

@@ -0,0 +1,36 @@
+# * George Moschovitis  <gm@navel.gr>
+# (c) 2004-2005 Navel, all rights reserved.
+# $Id$
+
+module N
+
+# 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

data/lib/glue/number.rb

@@ -0,0 +1,24 @@
+# * George Moschovitis  <gm@navel.gr>
+# (c) 2004-2005 Navel, all rights reserved.
+# $Id: number.rb 282 2005-03-10 12:24:53Z gmosx $
+
+module N;
+
+# 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

data/lib/glue/object.rb

@@ -0,0 +1,32 @@
+# * George Moschovitis  <gm@navel.gr>
+# (c) 2004-2005 Navel, all rights reserved.
+# $Id: object.rb 282 2005-03-10 12:24:53Z gmosx $
+
+# Code from RubyOnRails (http://www.rubyonrails.com)
+
+class Object #:nodoc:
+  def remove_subclasses_of(superclass)
+    subclasses_of(superclass).each { |subclass| Object.send(:remove_const, subclass) rescue nil }
+  end
+
+  def subclasses_of(superclass)
+    subclasses = []
+    ObjectSpace.each_object(Class) do |k|
+      next if !k.ancestors.include?(superclass) || superclass == k || k.to_s.include?("::") || subclasses.include?(k.to_s)
+      subclasses << k.to_s
+    end
+    subclasses
+  end
+end
+
+# Code from RubyOnRails (http://www.rubyonrails.com)
+
+class Class #:nodoc:
+  def remove_subclasses
+    Object.remove_subclasses_of(self)
+  end
+
+  def subclasses
+    Object.subclasses_of(self)
+  end
+end

data/lib/glue/pool.rb

@@ -0,0 +1,60 @@
+# * George Moschovitis  <gm@navel.gr>
+# (c) 2004-2005 Navel, all rights reserved.
+# $Id: pool.rb 282 2005-03-10 12:24:53Z gmosx $
+
+require 'thread'
+require 'monitor'
+
+module N
+
+# 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

data/lib/glue/property.rb

@@ -0,0 +1,408 @@
+# * George Moschovitis  <gm@navel.gr>
+# * Michael Neumann  <mneumann@ntecs.de>
+# (c) 2004-2005 Navel, all rights reserved.
+# $Id: property.rb 282 2005-03-10 12:24:53Z gmosx $
+
+require 'glue/attribute'
+require 'glue/array'
+require 'glue/hash'
+
+module N
+
+# 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:
+# Perhaps a sync is needed in evals (!!!!)
+#++
+
+class Property
+
+	# If set to true, perform type checking on property set. 
+	# Useful when debugging.
+
+	cattr_accessor :type_checking, false
+
+	# 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 declaration, sql index, etc)
+	# Here is a list of predefined metadata:
+	#
+	# [+:reader+]
+	#		create reader?
+	#
+	#	[+:writer+]
+	#		create writer?
+	#
+	#	[+:sql_index+]
+	#		create an sql index for the column this poperty maps to?
+	#
+	# You can use this mechanism to add your own, custom,
+	# metadata.
+	
+	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
+	
+	def to_s
+		return name
+	end
+
+end
+
+# A collection of Property related utility methods.
+
+module PropertyUtils
+
+	# Add accessors to the properties to the given target
+	# (Module or Class). For simplicity also create the
+	# meta accessors. 
+	#
+	# [+target+] 
+	#		The target class or module
+	#--
+	# gmosx: Perhaps we 'll optimize this in the future.
+	#++
+
+	def self.enchant(target, force = false)
+		unless target.singleton_methods.include?('__props')
+			target.module_eval %{  
+				@@__meta = N::SafeHash.new
+				@@__props = N::SafeArray.new
+				
+				def self.__props
+					@@__props
+				end
+
+				def self.__props=(props)
+					@@__props = props
+				end
+				
+				def self.__meta
+					@@__meta
+				end
+
+				def self.__meta=(meta)
+					@@__meta = meta
+				end
+			}
+		end
+	end
+
+	# Copy properties from src (Module or Class) to dest.
+	
+	def self.copy_props(src, dest)
+		src.__props.each do |p|
+			add_prop(dest, p)
+		end
+		
+		# copy the metadata.
+		src.__meta.each do |k, val|
+			dest.__meta[k] = val.dup
+			# val.each { |v| dest.meta(k, v) } if val
+		end
+	end
+
+	# Add the property to the target (Class or Module)
+	
+	def self.add_prop(target, prop)
+		if idx = target.__props.index(prop)
+			# override in case of duplicates. Keep the order of the props.
+			target.__props[idx] = prop
+		else
+			target.__props << prop
+		end
+
+		# Store the property in the :props_and_relations
+		# metadata array.
+
+		target.meta :props_and_relations, prop
+		
+		# Precompile the property read/write methods
+
+		s, klass = prop.symbol, prop.klass
+
+		if prop.meta[:reader]
+			target.module_eval %{
+				def #{s}
+					return @#{s}
+				end
+			}
+		end
+			
+		# gmosx: __force_xxx reuses xxx= to allow for easier
+		# overrides.
+
+		if prop.meta[:writer]
+			target.module_eval %{
+				#{prop_setter(prop)}
+				
+				def __force_#{s}(val)
+						self.#{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
+
+	# Generates the property setter code. Can be overriden
+	# to support extra functionality (example: markup)
+	
+	def self.prop_setter(prop)
+		s = prop.symbol
+
+		code = %{
+			def #{s}=(val)
+		}
+	
+		if N::Property.type_checking
+			code << %{
+				unless #{prop.klass} == val.class
+					raise "Invalid type, expected '#{prop.klass}', is '\#\{val.class\}'."
+				end
+			}
+		end
+
+		code << %{
+				@#{s} = val
+			end
+		}
+
+		return code
+	end
+
+	# Get the property metadata for the given symbol.
+
+	def self.get_prop(klass, sym)
+		return klass.__props.find { |p| p.symbol == sym }
+	end
+
+	# Include meta-language mixins
+	
+	def self.include_meta_mixins(target)
+		target.module_eval %{ include N::Validation } if defined?(N::Validation)
+		# gmosx: TODO, make Og::MetaLanguage equivalent to Validation.
+		target.module_eval %{ extend Og::MetaLanguage } if defined?(Og::MetaLanguage)
+	end
+
+	# Resolves the parameters passed to the propxxx macros
+	# to generate the meta, klass and symbols variables. This
+	# way the common functionality is factored out.
+	#
+	# [+params+]
+	#		The params to resolve.
+	#	[+one_symbol+]
+	#		If true, only resolves one symbol (used in prop).
+
+	def self.resolve_prop_params(*params)
+		meta = {}
+		klass = Object
+		symbols = []
+
+		for param in params.flatten
+			if param.is_a?(Class)
+				klass = param
+			elsif param.is_a?(Symbol)
+				symbols << param
+			elsif param.is_a?(TrueClass) or param.is_a?(TrueClass) 
+				writer = param
+			elsif param.is_a?(Hash)
+				# the meta hash.
+				meta.update(param) { |k, a, b| [a,b].join(' ') }
+			else
+				raise 'Error when defining property!'
+			end
+		end
+
+		raise 'No symbols provided!' if symbols.empty?
+
+		return meta, klass, symbols
+	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, symbols = N::PropertyUtils.resolve_prop_params(params) 	
+		symbol = symbols.first
+		
+		N::PropertyUtils.enchant(self)
+
+		if self.is_a?(Class)
+
+			# Add some extra code to append features to 
+			# subclasses.
+
+			self.module_eval %{ 
+				def self.inherited(sub)
+					N::PropertyUtils.enchant(sub)
+					N::PropertyUtils.copy_props(self, sub)
+					# gmosx: We have to define @@__props first to avoid reusing
+					# the hash from the module. super must stay at the end.
+					super
+				end
+			}
+		else
+
+			# Add some extra code for modules to append
+			# their features to classes that include it.
+			
+			self.module_eval %{ 
+				def self.append_features(base)
+					N::PropertyUtils.enchant(base)
+					N::PropertyUtils.copy_props(self, base)
+
+					# gmosx: We have to define @@__props first to avoid reusing
+					# the hash from the module. super must stay at the end.
+			
+					N::PropertyUtils.include_meta_mixins(base)
+					
+					super
+				end
+			}
+		end
+		
+		property = N::Property.new(symbol, klass, meta)
+		
+		reader = meta[:reader] || true
+		writer = writer || meta[:writer] || false
+	
+		meta[:reader] = true if meta[:reader].nil?
+		if defined?(writer)
+			meta[:writer] = writer 
+		else
+			meta[:writer] = true if meta[:writer].nil?
+		end
+
+		N::PropertyUtils.add_prop(self, property)
+
+		# gmosx: should be placed AFTER enchant!
+		
+		N::PropertyUtils.include_meta_mixins(self)
+	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, symbols = N::PropertyUtils.resolve_prop_params(params) 	
+		
+		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, symbols = N::PropertyUtils.resolve_prop_params(params) 	
+
+		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, symbols = N::PropertyUtils.resolve_prop_params(params) 	
+
+		meta[:reader] = true
+		meta[:writer] = true
+		
+		for symbol in symbols
+			prop(klass, symbol, meta)
+		end
+	end
+	alias_method :property, :prop_accessor
+	
+	# Attach metadata. 
+	# Guard against duplicates, no need to keep order.
+	# This method uses closures :)
+	#--
+	# gmosx: crappy implementation, recode.
+	#++
+	
+	def meta(key, *val)
+		val = val.first if val.size == 1
+
+		N::PropertyUtils.enchant(self)
+
+		self.module_eval %{  
+			@@__meta[key] ||= [] 
+			@@__meta[key].delete_if { |v| val == v }
+			@@__meta[key] << val			
+		}
+	end
+
+end