og 0.16.0 → 0.17.0

data/lib/og/database.rb

@@ -1,290 +0,0 @@
-# * George Moschovitis  <gm@navel.gr>
-# (c) 2004-2005 Navel, all rights reserved.
-# $Id: database.rb 19 2005-04-15 09:24:19Z gmosx $
-
-require 'glue/logger'
-require 'glue/attribute'
-require 'glue/property'
-require 'glue/array'
-require 'glue/hash'
-require 'glue/time'
-require 'glue/pool'
-require 'glue/aspects'
-
-require 'og/enchant'
-require 'og/meta'
-
-module Og
-	
-# Encapsulates an Og Database.
-
-class Database
-	include Enchant
-
-	# Managed class metadata
-	
-	class ManagedClassMeta
-		# The managed class.
-		attr_accessor :klass
-		
-		# A mapping of the database fields to the object properties.
-		attr_accessor :field_index
-		
-		def initialize(klass = nil)
-			@klass = klass
-			@field_index = {}
-		end
-	end
-
-	# hash of configuration options.
-
-	attr_accessor :config
-
-	# The adapter that comunicates with the backend
-	# datastore.
-
-	attr_accessor :adapter
-
-	# Pool of connections.
-	
-	attr_accessor :connection_pool
-
-	# Managed classes.
-	
-	attr_accessor :managed_classes
-
-	# Initialize the database interface.
-	
-	def initialize(config)
-		@config = config
-
-		# populate with default options if needed.
-		@config[:connection_count] ||= 5 
-		
-		Logger.info "Connecting to database '#{@config[:database]}' using the '#{@config[:adapter]}' adapter."
-
-		@adapter =  Adapter.for_name(@config[:adapter])
-
-		self.class.drop!(config) if config[:drop]
-		
-		@connection_pool = Pool.new
-		@managed_classes = SafeHash.new
-		
-		@config[:connection_count].times do
-			@connection_pool << @adapter.new_connection(self)
-		end
-	
-		auto_manage_classes if Og.auto_manage_classes
-
-		# use the newly created database.
-		Og.use(self)
-	end
-		
-	# Shutdown the database interface.
-	
-	def shutdown
-		for con in @connection_pool
-			con.close()
-		end
-	end
-	alias_method :close, :shutdown
-
-	# Get a connection from the pool to access the database.
-	# Stores the connection in a thread-local variable.
-
-	def get_connection
-		thread = Thread.current
-		
-		unless conn = thread[:og_conn]
-			conn = @connection_pool.pop()
-			thread[:og_conn] = conn
-		end
-		
-		return conn
-	end
-	alias_method :connection, :get_connection
-	
-	# Restore an unused connection to the pool.
-	
-	def put_connection
-		thread = Thread.current
-		
-		if conn = thread[:og_conn]
-			thread[:og_conn] = nil
-			return @connection_pool.push(conn)
-		end
-	end	
-	
-	# Utility method, automatically restores a connection to the pool.
-	
-	def connect(&block)
-		result = nil
-		
-		begin
-			conn = get_connection
-			result = yield(conn)
-		ensure
-			put_connection
-		end
-
-		return result
-	end
-	alias_method :open, :connect
-	
-	# Register a standard Ruby class as managed.
-	
-	def manage(klass)
-		return if managed?(klass) or klass.ancestors.include?(Unmanageable)
-		
-		@managed_classes[klass] = ManagedClassMeta.new(klass)
-		
-		# Add standard og methods to the class.
-		convert(klass)
-		
-		# Add helper methods to the class.
-		enchant(klass) if Og.enchant_managed_classes 
-	end
-	
-	# Helper method to set multiple managed classes.
-	
-	def manage_classes(*klasses)
-		for klass in klasses
-			manage(klass)
-		end
-	end
-
-	# Use Ruby's advanced reflection features to find
-	# and manage all manageable classes. Manageable are all
-	# classes that include Properties or Metadata.
-	#--
-	# gmosx, FIXME: this automanage code is not elegant and slow
-	# should probably recode this, along with glue/property.rb	
-	# FIXME: can this be optimized?
-	# TODO: find a better name.
-	#++
-
-	def auto_manage_classes
-		classes_to_manage = []
-
-		ObjectSpace.each_object(Class) do |c|
-			if c.respond_to?(:__props) and c.__props
-				classes_to_manage << c
-			end
-		end
-		
-		Logger.debug "Og auto manages the following classes:"
-		Logger.debug "#{classes_to_manage.inspect}"
-		
-		manage_classes(*classes_to_manage)
-	end
-	alias_method :auto_manage, :auto_manage_classes
-	
-	# Stop managing a Ruby class
-	
-	def unmanage(klass)
-		@managed_classes.delete(klass)
-	end
-	
-	# Is this class managed?
-	
-	def managed?(klass)
-		return @managed_classes.include?(klass)
-	end
-	
-	# Add standard og functionality to the class
-	
-	def convert(klass)
-		# gmosx: this check is needed to allow the developer to customize
-		# the sql generated for oid
-
-		@adapter.eval_og_oid(klass) unless klass.instance_methods.include?(:oid)
-		
-		klass.class_eval %{
-			DBTABLE = "#{Adapter.table(klass)}"
-			DBSEQ = "#{Adapter.table(klass)}_oid_seq" 
-
-			cattr_accessor :og_db
-
-			def to_i
-				@oid
-			end			
-		}
-
-		# Set the adapter.
-
-		klass.og_db = self
-		
-		# Create the schema for this class if not available.
-		
-		@adapter.create_table(klass, self) if Og.create_schema				
-		@adapter.eval_lifecycle_methods(klass, self)
-	end
-	
-	# Automatically wrap connection methods.
-	
-	def self.wrap_method(method, args)
-		args = args.split(/,/)
-		class_eval %{
-			def #{method}(#{args.join(", ")})
-				thread = Thread.current
-				
-				unless conn = thread[:og_conn]
-					conn = @connection_pool.pop()
-					thread[:og_conn] = conn
-				end
-			
-				return conn.#{method}(#{args.collect {|a| a.split(/=/)[0]}.join(", ")})
-			end
-		}
-	end
-
-	wrap_method :db, ''
-	wrap_method :create_table, 'klass'
-	wrap_method :drop_table, 'klass'
-	wrap_method :save, 'obj';	alias_method :<<, :save; alias_method :put, :save
-	wrap_method :insert, 'obj'
-	wrap_method :update, 'obj'
-	wrap_method :update_properties, 'update_sql, obj_or_oid, klass = nil'
-	wrap_method :pupdate, 'update_sql, obj_or_oid, klass = nil'
-	wrap_method :load, 'oid, klass'; alias_method :get, :load	
-	wrap_method :load_by_oid, 'oid, klass'
-	wrap_method :load_by_name, 'name, klass'	
-	wrap_method :load_all, 'klass, extrasql = nil'
-	wrap_method :select, 'sql, klass'
-	wrap_method :select_one, 'sql, klass'
-	wrap_method :count, 'sql, klass = nil'
-	wrap_method :delete, 'obj_or_oid, klass = nil'	
-	wrap_method :prepare, 'sql'
-	wrap_method :query, 'sql'
-	wrap_method :exec, 'sql'
-	wrap_method :get_row, 'res'
-	wrap_method :transaction, '&block'
-
-	class << self
-
-		# Create a new database.
-
-		def create_db!(config)
-			adapter = Adapter.for_name(config[:adapter])
-			adapter.create_db(config[:database], config[:user], config[:password])
-		end
-		alias_method :create!, :create_db!
-
-		# Drop an existing database.
-
-		def drop_db!(config)
-			adapter = Adapter.for_name(config[:adapter])
-			adapter.drop_db(config[:database], config[:user], config[:password])
-		end
-		alias_method :drop!, :drop_db!
-		
-	end
-end
-
-# Helper method
-
-def self.connect(*args)
-	db = Database.new(*args)
-end
-
-end

data/lib/og/enchant.rb

@@ -1,149 +0,0 @@
-# * George Moschovitis  <gm@navel.gr>
-# (c) 2004-2005 Navel, all rights reserved.
-# $Id: enchant.rb 1 2005-04-11 11:04:30Z gmosx $
-
-module Og
-
-module Enchant
-
-	# Enchant a managed class. Add useful DB related methods 
-	# to the class and its instances. 
-	
-	def enchant(klass)
-
-		# Generate standard methods.
-		
-		klass.module_eval %{ 
-			def self.create(*params, &block)
-				obj = #{klass}.new(*params, &block)
-				obj.save!
-			end
-				
-			def self.save(obj)
-				@@og_db << obj
-			end
-			
-			def self.load(oid_or_name)
-				@@og_db.load(oid_or_name, #{klass})
-			end
-
-			def self.get(oid_or_name)
-				@@og_db.load(oid_or_name, #{klass})
-			end
-			
-			def self.[](oid_or_name)
-				@@og_db.load(oid_or_name, #{klass})
-			end
-			
-			def self.load_all(extra_sql = nil)
-				@@og_db.load_all(#{klass}, extra_sql)
-			end
-			
-			def self.all(extra_sql = nil)
-				@@og_db.load_all(#{klass}, extra_sql)
-			end
-
-			def self.update_all(set_sql, extra_sql = nil)
-				@@og_db.exec("UPDATE #{klass::DBTABLE} SET \#\{set_sql\} \#\{extra_sql\}")
-			end
-
-			def self.update(set_sql, extra_sql = nil)
-				@@og_db.exec("UPDATE #{klass::DBTABLE} SET \#\{set_sql\} \#\{extra_sql\}")
-			end
-
-			def self.count(sql = "SELECT COUNT(*) FROM #{klass::DBTABLE}")
-				@@og_db.count(sql, #{klass})
-			end
-
-			def self.select(sql)
-				@@og_db.select(sql, #{klass})
-			end
-			
-			def self.find(sql)
-				@@og_db.select(sql, #{klass})
-			end
-
-			def self.select_one(sql)
-				@@og_db.select_one(sql, #{klass})
-			end
-
-			def self.find_one(sql)
-				@@og_db.select_one(sql, #{klass})
-			end
-
-			def self.one(sql)
-				@@og_db.select_one(sql, #{klass})
-			end
-			
-			def self.delete(obj_or_oid)
-				@@og_db.delete(obj_or_oid, #{klass})
-			end
-
-			def self.transaction(&block)
-				@@og_db.transaction(&block)
-			end
-
-			def self.properties_and_relations
-				@@__meta[:props_and_relations]
-			end
-
-			def self.each(&block)
-				all.each(&block)
-			end
-			include Enumerable
-			
-			def save
-				@@og_db << self
-				return self
-			end
-			alias_method :save!, :save
-
-			def reload
-				raise 'Cannot reload unmanaged object' unless @oid
-				res = @@og_db.query "SELECT * FROM #{klass::DBTABLE} WHERE oid=\#\{@oid\}"
-				og_read(@@og_db.get_row(res))
-			end
-			alias_method :reload!, :reload
-
-			def update_properties(updatesql)
-				@@og_db.pupdate(updatesql, self.oid, #{klass})
-			end
-			alias_method :pupdate, :update_properties
-			alias_method :update_property, :update_properties
-
-			def set_property(prop, value)
-				@@og_db.pupdate("\#\{prop\}=\#\{value\}", self.oid, #{klass})
-			end
-			
-			def delete!
-				@@og_db.delete(self, #{klass})
-			end
-		}
-
-		# Generate finder methods.
-	
-		code = ''
-		
-		for p in klass.__props
-			code << %{
-				def self.find_by_#{p.name}(val, operator = '=', extra_sql = nil)
-			}
-
-			val = klass.og_db.adapter.typecast[p.klass].gsub(/\:s\:/, 'val')
-			
-			if p.meta[:unique]
-				code <<	%{@@og_db.select_one("#{p.name}\#\{operator\}#{val} \#\{extra_sql\}", #{klass})}
-			else
-				code <<	%{@@og_db.select("#{p.name}\#\{operator\}#{val} \#\{extra_sql\}", #{klass})}
-			end
-			code << %{
-				end; 
-			}
-		end
-	
-		klass.module_eval(code)
-	end
-
-end
-	
-end

data/lib/og/meta.rb

@@ -1,407 +0,0 @@
-# * George Moschovitis  <gm@navel.gr>
-# (c) 2005 Navel, all rights reserved.
-# $Id: meta.rb 1 2005-04-11 11:04:30Z gmosx $
-#--
-# TODO:
-# - precreate the meta sql statements as much as possible to 
-#   avoid string interpolations.
-#++
-
-require 'glue/inflector'
-require 'og/adapters/base'
-require 'og/typemacros'
-
-module Og
-
-class Relation < Property
-	alias foreign_class klass
-end
-
-class Has < Relation; end
-class HasMany < Has; end
-class HasOne < Has; end
-class ManyToMany < Has; end
-class BelongsTo < Relation; end
-class RefersTo < Relation; end
-	
-# Some useful meta-language utilities.
-
-module MetaUtils # :nodoc: all
-
-	# Convert the klass to a string representation
-	# The leading module if available is removed.
-	#--
-	# gmosx, FIXME: unify with the ogutils.encode method?
-	#++
-	
-	def self.expand(klass)
-		return klass.name.gsub(/^.*::/, '').gsub(/::/, '_').downcase
-	end
-
-	# Infer the target klass for a relation. When defining
-	# relations, tha target class is typically given. Some times
-	# in order to avoid forward declarations a symbol is given instead
-	# of a class. Other times on class is given at all, and 
-	# the inflection mechanism is used to infer the class name.
-	#--
-	# This is not used yet.
-	#++
-
-	def self.resolve_class(name, klass)
-		klass ||= Inflector.camelize(name)
-		
-		return klass if klass.is_a?(Class)
-		
-		unless klass.is_a?(String) or klass.is_a?(Symbol)
-			raise 'Invalid class definition' 
-		end
-	
-		unless Object.const_get(klass.intern)
-			# Forward declaration.
-			Object.class_eval("class #{klass}; end")
-		end
-
-		return Object.const_get(klass)
-	end
-
-end
-
-# Implements a meta-language for manipulating og-managed objects
-# and defining their relationships. The original idea comes
-# from the excellent ActiveRecord library.
-#
-# Many more useful relations will be available soon.
-
-module MetaLanguage
-
-	# Defines an SQL index. Useful for defining indiced
-	# over multiple columns.
-	
-	def sql_index(index, options = {})
-		meta :sql_index, [index, options]
-	end
-
-	# Implements a 'belongs_to' relation.
-	# Automatically enchants the calling class with helper methods.
-	# 
-	# Example:
-	#
-	# class MyObject
-	#		belongs_to AnotherObject, :prop => :parent
-	# end
-	#
-	# creates the code:
-	#
-	# prop_accessor Fixnum, :parent_oid
-	# def parent; ... end
-	# def parent=(obj_or_oid); ... end
-	
-	def belongs_to(name, klass, options = {})
-		prop_eval = "prop_accessor Fixnum, :#{name}_oid"
-		prop_eval << ", :sql => '#{options[:sql]}'" if options[:sql]
-		prop_eval << ", :extra_sql => '#{options[:extra_sql]}'" if options[:extra_sql]
-
-		meta :props_and_relations, BelongsTo.new(name, klass, :property => "#{name}_oid".intern)
-		
-		module_eval %{
-			#{prop_eval}
-			
-			def #{name}
-				Og.db.load_by_oid(@#{name}_oid, #{klass})
-			end
-			
-			def #{name}=(obj_or_oid)
-				@#{name}_oid = obj_or_oid.to_i
-			end
-		}
-	end
-
-	# Implements a 'has_one' relation.
-	# Automatically enchants the calling class with helper methods.
-	#
-	# Example:
-	#
-	# class MyObject
-	#		has_one :child, TheClass
-	#		has_one :article
-	# end
-	#
-	# creates the code:
-	#
-	# ...
-	
-	def has_one(name, klass = nil, options = {})
-
-		# linkback is the property of the child object that 'links back' 
-		# to this object. 
-
-		linkback = (options[:linkback].to_s || "#{MetaUtils.expand(self)}_oid").to_s
-		
-		meta :descendants, klass, linkback
-		meta :props_and_relations, HasOne.new(name, klass, options)
-		
-		module_eval %{
-			def #{name}(extrasql = nil)
-				Og.db.select_one("SELECT * FROM #{Og::Adapter.table(klass)} WHERE #{linkback}=\#\@oid \#\{extrasql\}", #{klass})
-			end
-
-			def delete_#{name}(extrasql = nil)
-				Og.db.exec("DELETE FROM #{Og::Adapter.table(klass)} WHERE #{linkback}=\#\@oid \#\{extrasql\}") 
-			end			
-		}
-	end	
-
-	# Implements a 'has_many' relation.
-	# Automatically enchants the calling class with helper methods.
-	# 
-	# Options:
-	#
-	# [+linkback+]
-	# 
-	#	[+order+]
-	#
-	# [+extrasql+]
-	#
-	# Example:
-	#
-	# class MyObject
-	#		has_many :articles, Article
-	# end
-	#
-	# creates the code:
-	#
-	# obj.articles 
-	# obj.add_article(article)
-	# obj.add_article do |a|
-	#		a.title = 'Title'
-	#		a.body = 'Body'
-	#	end
-	
-	def has_many(name, klass, options = {})
-		name_s = Inflector.singularize(name.to_s)
-		
-		# linkback is the property of the child object that 'links back' 
-		# to this object. 
-
-		linkback = (options[:linkback] || "#{MetaUtils.expand(self)}_oid").to_s
-
-		if order = options[:order]
-			order = "ORDER BY #{order}"
-		end
-		default_extrasql = "#{order}#{options[:sql]}"
-		
-		# keep belongs to metadata, useful for 
-		# reflection/scaffolding.
-
-		meta :descendants, klass, linkback
-		meta :props_and_relations, HasMany.new(name, klass, options)
-
-		code = %{
-			def #{name}(extrasql = nil)
-				Og.db.select("SELECT * FROM #{Og::Adapter.table(klass)} WHERE #{linkback}=\#\@oid #{default_extrasql} \#\{extrasql\}", #{klass})
-			end
-
-			def #{name}_count(extrasql = nil)
-				Og.db.count("SELECT COUNT(*) FROM #{Og::Adapter.table(klass)} WHERE #{linkback}=\#\@oid \#\{extrasql\}")
-			end			
-
-			def add_#{name_s}(obj = nil)
-				yield(obj = #{klass}.new) unless obj
-		}
-		if Og.check_implicit_graph_changes
-			code << %{
-				if obj.#{linkback}
-					Logger.warn "Implicit graph change for object #{obj.inspect}"
-				end
-			}
-		end
-		code << %{
-				obj.#{linkback} = @oid
-				obj.save!
-			end
-			
-			def delete_all_#{name}(extrasql = nil)
-				Og.db.exec("DELETE FROM #{Og::Adapter.table(klass)} WHERE #{linkback}=\#\@oid \#\{extrasql\}") 
-			end			
-		}
-
-		module_eval(code)
-	end
-	
-	# Implements a 'many_to_many' relation.
-	# Two objects are associated using an intermediate join table.
-	# Automatically enchants the calling class with helper methods.
-	#
-	# Options:
-	#
-	# Example:
-	#
-	# class Article
-	# 	many_to_many :categories, Category, :linkback => articles
-	# end
-	#
-	# article.categories
-	# article.del_category
-	# article.add_category
-	# article.add_category { |c| ... }
-	#	article.clear_categories
-	#
-	# category.articles
-	# ...
-	#--
-	# FIXME: make more compatible with other enchant methods.
-	#++
-	
-	def many_to_many(name, klass, options = {})
-		list_o = name.to_s
-		prop_o = Inflector.singularize(list_o)
-		list_m = (options[:linkback] || Inflector.plural_name(self)).to_s
-		prop_m = Inflector.singularize(list_m)
-	
-		# Exit if the class is allready indirectly 'enchanted' from the
-		# other class of the many_to_many relation.
-
-		return if self.respond_to?(prop_m)
-	
-		# Add some metadata to the class to allow for automatic join table
-		# calculation.
-
-		meta :sql_join, name, klass, options
-
-		# FIXME: should add metadata for cascading delete.
-
-		meta :props_and_relations, ManyToMany.new(prop_o, klass)
-		klass.meta :props_and_relations, ManyToMany.new(prop_m, self)
-
-		# Enchant this class
-		
-		module_eval %{
-			def #{list_o}(extrasql = nil)
-				Og.db.select("SELECT d.* FROM #{Og::Adapter.table(klass)} d, #{Og::Adapter.join_table(self, klass, name)} j WHERE j.key1=\#\@oid AND j.key2=d.oid \#\{extrasql\}", #{klass})
-		end
-
-			def #{list_o}_count(extrasql = nil)
-				Og.db.select("SELECT COUNT(*) FROM #{Og::Adapter.table(klass)} d, #{Og::Adapter.join_table(self, klass, name)} j WHERE j.key1=\#\@oid AND j.key2=d.oid \#\{extrasql\}", #{klass})
-			end						
-			
-			def add_#{prop_o}(obj = nil)
-				yield(obj = #{klass}.new) unless obj
-				obj.save! unless obj.oid
-				Og.db.exec("INSERT INTO #{Og::Adapter.join_table(self, klass, name)} (key1, key2) VALUES (\#\@oid, \#\{obj.oid\})") 
-			end
-			
-			def delete_#{prop_o}(obj_or_oid)
-				Og.db.exec("DELETE FROM #{Og::Adapter.join_table(self, klass, name)} WHERE key2=\#\{obj_or_oid.to_i\}") 
-			end
-
-			def clear_#{list_o}
-				Og.db.exec("DELETE FROM #{Og::Adapter.join_table(self, klass, name)} WHERE key1=\#\@oid") 
-			end			
-		}
-		
-		# indirectly enchant the other class of the relation.
-		
-		klass.module_eval %{
-			def #{list_m}(extrasql = nil)
-				Og.db.select("SELECT s.* FROM #{Og::Adapter.table(self)} s, #{Og::Adapter.join_table(self, klass, name)} j WHERE j.key2=\#\@oid AND j.key1=s.oid \#\{extrasql\}", #{self})
-			end
-
-			def #{list_m}_count(extrasql = nil)
-				Og.db.select("SELECT COUNT(*) FROM #{Og::Adapter.table(self)} s, #{Og::Adapter.join_table(self, klass, name)} j WHERE j.key2=\#\@oid AND j.key1=s.oid \#\{extrasql\}", #{self})
-			end
-			
-			def add_#{prop_m}(obj = nil)
-				yield(obj = #{self}.new) unless obj
-				obj.save! unless obj.oid
-				Og.db.exec("INSERT INTO #{Og::Adapter.join_table(self, klass, name)} (key1, key2) VALUES (\#\{obj.oid\}, \#\@oid)") 
-			end
-			
-			def delete_#{prop_m}(obj_or_oid)
-				Og.db.exec("DELETE FROM #{Og::Adapter.join_table(self, klass, name)} WHERE key1=\#\{obj_or_oid.to_i\}") 
-			end
-
-			def clear_#{list_m}
-				Og.db.exec("DELETE FROM #{Og::Adapter.join_table(self, klass, name)} WHERE key2=\#\@oid") 
-			end			
-		}
-	end
-	alias :has_and_belongs_to_many :many_to_many 
-
-	# Implements a 'refers_to' relation.
-	# This is a one-way version of the 'has_one'/'belongs_to' 
-	# relations. The target object cannot link back to the source
-	# object.
-	# This is in fact EXACTLY the same as belongs_to with a 
-	# different name (!!!!)
-	#
-	# Automatically enchants the calling class with helper methods.
-	# 
-	# 
-	# Example:
-	#
-	# class MyObject
-	#		refers_to article, Article
-	# end
-	#
-	# creates the code:
-	#
-	# prop_accessor Fixnum, :article_oid
-	# def article; ... end
-	# def article=(obj_or_oid); ... end
-
-	def refers_to(name, klass, options = {})
-		prop_eval = "prop_accessor Fixnum, :#{name}_oid"
-		prop_eval << ", :sql => '#{options[:sql]}'" if options[:sql]
-		prop_eval << ", :extra_sql => '#{options[:extra_sql]}'" if options[:extra_sql]
-
-		meta :props_and_relations, RefersTo.new(name, klass, :property => "#{name}_oid".intern)
-		klass.meta :descendants, self, "#{name}_oid".intern
-		
-		module_eval %{
-			#{prop_eval}
-			
-			def #{name}
-				Og.db.load_by_oid(@#{name}_oid, #{klass})
-			end
-			
-			def #{name}=(obj_or_oid)
-				@#{name}_oid = obj_or_oid.to_i
-			end
-		}
-	end
-
-	# Declares that this class can join with another class.
-	# The join parameters are given so the join-compatible 
-	# methods are generated.
-
-	def joins(klass, options = {})
-		meta :joins, klass, options
-	end
-
-end
-
-end
-
-# Include the meta-language extensions into Module. If the flag is
-# false the developer is responsible for including the MetaLanguage
-# module where needed.
-# 
-# By default this is FALSE, to avoid polution of the Module object.
-# However if you include a prop_accessor or a managed Mixin in your
-# object MetaLanguage gets automatically extended in the class.
-
-if Og.include_meta_language
-	class Module # :nodoc: all
-		include Og::MetaLanguage
-
-=begin
-		A hack to avoid forward references. Does not work
-		with namespave modules though. Any idea?
-		-> try TOPLEVEL_BINDING
-
-		def const_missing(sym)
-			eval "class ::#{sym}; end; return #{sym}"
-		end
-=end
-	end
-end