ObjectModel 0.3.0

data/lib/ObjectModel/Indexes/IndexStorage.rb

@@ -0,0 +1,64 @@
+class IndexStorage	
+	inherit Log
+	
+	attr_reader :db
+	attr_writer :index_manager
+	
+	def initialize name, dir
+		folder = File.expand_path "#{dir}/#{name}"
+		Dir.mkdir folder unless File.exist? folder		
+		@db = Sequel.connect("sqlite://#{folder}/#{name}_indexes.db")
+		@db.logger = log
+		
+		initialize_db unless @db.table_exists? :metadata						
+		
+		@metadata ||= @db[:metadata]		
+		@tables = {}		
+	end
+	
+	def [] type
+		@tables[type] ||= @db[type]
+	end
+	
+	def generate generator_name
+		generator_name = generator_name.to_s
+		@db.transaction do 
+			unless row = @metadata[:key => generator_name]
+				@metadata << {:key => generator_name, :value => "0"}
+				row = @metadata[:key => generator_name]
+			end
+			id = @metadata[:key => generator_name.to_s][:value].to_i
+			@metadata.filter(:key => generator_name).update(:value => (id + 1).to_s)
+			return id.to_s
+		end
+	end
+		
+	def close
+		@tables.clear
+		@db.disconnect
+	end
+	
+	def transaction &b
+		@db.transaction &b
+	end	
+	
+	def print name = nil
+		@index_manager.indexes.values.each{|index| index.print_storage name}
+	end
+	
+	protected 
+	def initialize_db
+		@db.create_table :metadata do
+			column :key, :text
+			column :value, :text
+			primary_key :key
+#			index :key
+		end				
+		
+		@metadata = @db[:metadata]
+#		@metadata << {:key => "entity_id", :value => "0"}
+#		@metadata << {:key => "name", :value => "0"}
+#		@metadata << {:key => "stream_id", :value => "0"}
+		@metadata << {:key => "size", :value => "0"}
+	end
+end

data/lib/ObjectModel/Indexes/Manager.rb

@@ -0,0 +1,72 @@
+class Manager
+	attr_accessor :indexes
+	
+	def initialize repository
+		@repository = repository
+		@indexes = Hash.new{|hash, key| raise_without_self "No Index - '#{key}'!", ObjectModel}
+		@not_initialized = Set.new
+	end
+	
+	def add index
+		index.name.should! :be_a, Symbol
+		@indexes[index.name] = index		
+		index.storage = @repository.indexes_storage
+		index.repository = @repository
+		builded = index.create_index
+		@not_initialized << index unless builded
+	end		
+	
+	def delete index_name
+		index_name.should! :be_a, Symbol
+		index = @indexes.delete index_name
+		index.should_not! :be_nil
+		index.delete_index
+		@not_initialized.delete index
+	end
+	
+	def update transaction		
+		Thread.current[:om_transaction].should_not! :be_nil		
+		@not_initialized.should! :be_empty
+		
+		@repository.indexes_storage.transaction do
+			indexes = @indexes.values
+			transaction.copies.each do |entity_id, c| 
+				e = transaction.resolve entity_id
+				indexes.every.update e, c					
+			end
+		end
+	end
+	
+	def [] name		
+		check_transaction	
+		@not_initialized.should! :be_empty
+		return @indexes[name]
+	end
+	
+	def get_index_without_transaction_check name
+		@not_initialized.should! :be_empty
+		return @indexes[name]
+	end		
+	
+	def clear_indexes
+		check_transaction
+		@indexes.values.every.delete_index
+		@not_initialized.replace @indexes.values
+	end
+	
+	def build_indexes
+		check_transaction
+		@not_initialized.every.create_index
+		@repository.indexes_storage.transaction do
+			@repository.each{|e| @not_initialized.every.add e}
+		end
+		@not_initialized.clear
+	end		
+	
+	protected
+	def check_transaction
+		#		if Thread.current[:om_transaction]
+		#			raise_without_self "Forbiden to use Indexes inside Transaction!", ObjectModel
+		#		end
+	end
+end

data/lib/ObjectModel/Metadata.rb

@@ -0,0 +1,34 @@
+class Metadata 
+	ATTRIBUTE_TYPES_SHORTCUTS = self["attribute_types_shortcuts.rb"]
+	CHILD_TYPES_SHORTCUTS = self["child_types_shortcuts.rb"]
+	REFERENCE_TYPES_SHORTCUTS = self["reference_types_shortcuts.rb"]
+	
+	BEFORE_EVENT_TYPES = self["before_event_types.rb"]
+	AFTER_EVENT_TYPES = self["after_event_types.rb"]
+	
+	attr_accessor :klass
+	
+	def initialize klass
+		super()
+		@klass = klass
+		Metadata.definition.each do |name, defn|
+			send name.to_writer, defn.initial_value(@klass)
+		end
+	end
+	
+	def inherit parent
+		new = Metadata.new klass
+		Metadata.definition.each do |name, defn|
+			pmeta = parent.send name
+			cmeta = self.send name
+			new.send name.to_writer, defn.inherit(pmeta, cmeta)
+		end
+		return new
+	end		
+	
+	class << self		
+		def definition
+			@definition ||= {}
+		end
+	end
+end

data/lib/ObjectModel/Metadata.res/after_event_types.rb

@@ -0,0 +1,25 @@
+[
+:attribute_update,
+
+:name_update,
+
+:new_reference,
+:delete_reference,
+
+:new_referrer,
+:delete_referrer,
+
+:new_child,
+:delete_child,
+
+:new_parent,
+:delete_parent,
+
+:new,
+:delete,
+:move,
+
+:commit,
+
+#:containment_update,
+].to_set

data/lib/ObjectModel/Metadata.res/attribute_types_shortcuts.rb

@@ -0,0 +1,10 @@
+{
+	:string => Types::StringType,
+	:number => Types::NumberType,
+	:boolean => Types::BooleanType,
+	:object => Types::ObjectType,
+	:date => Types::DateType,
+	:data => Types::DataType,
+	:proc => Types::ProcType,
+	:class => Types::ClassType,
+}

data/lib/ObjectModel/Metadata.res/before_event_types.rb

@@ -0,0 +1,25 @@
+[
+:attribute_update,
+
+:name_update,
+
+:new_reference,
+:delete_reference,
+
+:new_referrer,
+:delete_referrer,
+
+:new_child,
+:delete_child,
+
+:new_parent,
+:delete_parent,
+
+:new,
+:delete,
+:move,
+
+:commit,
+
+#:containment_update,
+].to_set

data/lib/ObjectModel/Metadata.res/child_types_shortcuts.rb

@@ -0,0 +1,4 @@
+{
+	:bag => Types::BagType,
+	:single => Types::SingleType,
+}

data/lib/ObjectModel/Metadata.res/metadata_checks.rb

@@ -0,0 +1,9 @@
+[
+lambda do |klass, meta|
+	a = meta.attributes.keys.to_set
+	c = meta.children.keys.to_set
+	r = meta.references.keys.to_set
+	dup = (a & c) + (a & r) + (c & r)
+	raise "The same name '#{dup.inspect}' used for attribute/child/reference definition!" unless dup.empty?
+end,
+]

data/lib/ObjectModel/Metadata.res/reference_types_shortcuts.rb

@@ -0,0 +1,4 @@
+{
+	:bag => Types::BagType,
+	:single => Types::SingleType,
+}

data/lib/ObjectModel/Metadata/DSL.rb

@@ -0,0 +1,11 @@
+class DSL
+	def initialize klass, &block
+		@klass = klass
+		@meta = Metadata.new klass
+		@klass.self_meta = @meta
+		self.instance_eval &block
+		
+		full_meta = klass.meta
+		Metadata["metadata_checks.rb"].each{|check| check.call klass, full_meta}
+	end
+end

data/lib/ObjectModel/Metadata/attribute.rb

@@ -0,0 +1,56 @@
+module ObjectModel
+	class Metadata
+		class Attributes < Hash
+			def initialize
+				super{should! :be_never_called}
+			end
+			
+			def copy
+				c = Attributes.new
+				each{|n, m| c[n] = m.copy}
+				return c
+			end
+			
+			def inherit parent
+				parent.copy.merge copy
+			end		
+		end
+		
+		class Attribute
+			include OpenConstructor
+			
+			attr_accessor :name, :ivname, :title, :type, :initialize, :parameters, :validate
+			public :initialize
+			
+			def copy; clone end
+		end
+		
+		definition[:attributes] = Object.new.singleton_class do
+			def initial_value klass; Attributes.new end
+			
+			def copy attributes; attributes.copy end
+			
+			def inherit pvalue, cvalue;  
+				cvalue.inherit pvalue
+			end						
+		end
+		
+		attr_accessor :attributes
+		
+		class DSL
+			def attribute name, type = :object, other = {}				
+				type.should! :be_in, Metadata::ATTRIBUTE_TYPES_SHORTCUTS
+				values = {
+					:name => name, 
+					:ivname => name.to_iv, 
+					:type => Metadata::ATTRIBUTE_TYPES_SHORTCUTS[type],
+					:initialize => NotDefined
+				}.merge(other)
+				attr = Attribute.new.set_with_check values				
+				@meta.attributes[name] = attr
+				
+				@klass._define_attribute attr
+			end
+		end
+	end
+end

data/lib/ObjectModel/Metadata/child.rb

@@ -0,0 +1,50 @@
+module ObjectModel
+	class Metadata
+		class Children < Hash
+			def initialize
+				super{should! :be_never_called}
+			end
+			
+			def copy
+				c = Children.new
+				each{|n, m| c[n] = m.copy}
+				return c
+			end
+			
+			def inherit parent
+				parent.copy.merge copy
+			end												
+		end
+		
+		class Child
+			include OpenConstructor
+			
+			attr_accessor :name, :ivname, :title, :type, :parameters
+			
+			def copy; clone end
+		end
+		
+		definition[:children] = Object.new.singleton_class do
+			def initial_value klass; Children.new end
+			
+			def copy children; children.copy end
+			
+			def inherit pvalue, cvalue;  
+				cvalue.inherit pvalue
+			end						
+		end
+		
+		attr_accessor :children
+		
+		class DSL
+			def child name, type = :single, other = {}				
+				type.should! :be_in, Metadata::CHILD_TYPES_SHORTCUTS
+				values = {:name => name, :ivname => name.to_iv, :type => Metadata::CHILD_TYPES_SHORTCUTS[type]}.merge(other)
+				child = Child.new.set_with_check values				
+				@meta.children[name] = child
+				
+				@klass._define_child child
+			end
+		end
+	end
+end

data/lib/ObjectModel/Metadata/events.rb

@@ -0,0 +1,109 @@
+module ObjectModel
+	class Metadata
+		class BaseEvents < Hash
+			def initialize
+				super{should! :be_never_called}
+			end
+			
+			def copy
+				c = self.class.new
+				each{|n, m| c[n] = m.clone}
+				return c
+			end
+			
+			def inherit parent
+				r = parent.copy
+				copy.each do |n, m|
+					if r.include? n
+						r[n] += m
+					else
+						r[n] = m
+					end
+				end
+				return r
+			end								
+		end
+		
+		class BeforeEvents < BaseEvents
+			def fire entity, event_name, *params
+				event_name.should! :be_in, Metadata::BEFORE_EVENT_TYPES
+				if self.include? event_name
+					self[event_name].each{|event| event.fire entity, *params}
+				end
+			end
+		end
+		
+		class AfterEvents < BaseEvents
+			def fire entity, event_name, *params
+				event_name.should! :be_in, Metadata::AFTER_EVENT_TYPES
+				if self.include? event_name
+					self[event_name].each{|event| event.fire entity, *params}
+				end
+			end
+		end
+		
+		class Event
+			attr_reader :method, :block
+			
+			def initialize method = nil, &block
+				if method
+					method.should! :be_a, Symbol
+					block.should! :be_nil
+					@method = method					
+				elsif block
+					method.should! :be_nil
+					@block = block
+				else
+					should! :be_never_called
+				end
+			end
+			
+			def fire entity, *params
+				if @method
+					entity.send @method, *params
+				elsif @block
+					entity.instance_eval &@block
+				else
+					should! :be_never_called
+				end
+			end
+		end
+		
+		definition[:before] = Object.new.singleton_class do
+			def initial_value klass; BeforeEvents.new end
+			
+			def copy events; events.copy end
+			
+			def inherit pvalue, cvalue;  
+				cvalue.inherit pvalue
+			end
+		end
+		
+		definition[:after] = Object.new.singleton_class do
+			def initial_value klass; AfterEvents.new end
+			
+			def copy events; events.copy end
+			
+			def inherit pvalue, cvalue;  
+				cvalue.inherit pvalue
+			end
+		end
+		
+		attr_accessor :before
+		attr_accessor :after
+		
+		class DSL			
+			def after name, method = nil, &block
+				name.should! :be_in, Metadata::AFTER_EVENT_TYPES
+				e = Event.new method, &block
+				@meta.after[name] = [e]
+			end
+			
+			def before name, method = nil, &block
+				name.should! :be_in, Metadata::AFTER_EVENT_TYPES
+				e = Event.new method, &block
+				@meta.before[name] = [e]
+			end
+		end
+	end
+end