ObjectModel 0.3.0

data/lib/ObjectModel/Repository/EventProcessor.rb

@@ -0,0 +1,58 @@
+class EventProcessor
+	def initialize transaction
+		@transaction = transaction
+		@before_history = []
+	end		
+	
+	def fire_before entity, event, *params
+		entity.should! :be_a, Entity
+		event.should! :be_in, Metadata::BEFORE_EVENT_TYPES
+		
+		l_event = :"before_#{event}"
+		@transaction.repository.entity_listeners.each{|l| l.respond_to l_event, entity, *params}
+		@transaction.system_listener.respond_to l_event, entity, *params
+		
+		entity.meta.before.fire entity, event, *params		
+	end
+	
+	def fire_after entity, event, *params
+		entity.should! :be_a, Entity
+		event.should! :be_in, Metadata::AFTER_EVENT_TYPES
+		
+		l_event = :"after_#{event}"
+		@transaction.repository.entity_listeners.each{|l| l.respond_to l_event, entity, *params}
+		@transaction.system_listener.respond_to l_event, entity, *params
+		
+		entity.meta.after.fire entity, event, *params
+	end
+	
+	def fire_before_commit
+		entities = []
+		@transaction.copies.each do |entity_id, c|
+			entities << @transaction.resolve(entity_id)												
+		end
+		
+		@transaction.repository.entity_listeners.each{|l| l.respond_to :before_commit, entities}
+		@transaction.system_listener.respond_to :before_commit, entities					
+		
+		entities.each{|e| e.meta.before.fire e, :commit}
+	end
+	
+	def fire_after_commit
+		entities = []
+		@transaction.copies.each do |entity_id, c|
+			entity = if @transaction.deleted_entities.include? entity_id
+				@transaction.deleted_entities[entity_id]
+			else
+				@transaction.repository.by_id entity_id
+			end
+			entities << entity			
+		end		
+		
+		# :after_commit
+		@transaction.repository.entity_listeners.each{|l| l.respond_to :after_commit, entities}
+		@transaction.system_listener.respond_to :after_commit, entities					
+		
+		entities.each{|e| e.meta.after.fire e, :commit}
+	end
+end

data/lib/ObjectModel/Repository/ObjectStorage.rb

@@ -0,0 +1,102 @@
+class ObjectStorage	
+	inherit Log
+	TYPES_TO_INITIALIZE = []
+	
+	attr_reader :metadata
+	
+	def initialize name, dir
+		folder = File.expand_path "#{dir}/#{name}" #.sub(/^\.\//, "")
+		Dir.mkdir folder unless File.exist? folder		
+		@db = Sequel.connect("sqlite://#{folder}/#{name}.db")
+		@db.logger = log
+		
+		unless @db.table_exists? :metadata						
+			initialize_db 
+			TYPES_TO_INITIALIZE.each{|type| type.initialize_storage @db}
+		end
+		
+		@metadata ||= @db[:metadata]		
+		@custom_metadata ||= @db[:custom_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 size
+		@db.transaction do 
+			id = @metadata[:key => "size"][:value].to_i			
+		end
+	end
+	
+	def size= value
+		@db.transaction do 
+			value.should! :be_a, Number
+			@metadata.filter(:key => "size").update(:value => value.to_s)
+		end
+	end
+	
+	def close
+		@tables.clear
+		@db.disconnect
+	end
+	
+	def transaction &b
+		@db.transaction &b
+	end			
+	
+	def print name = nil
+		TYPES_TO_INITIALIZE.each{|type| type.print_storage @db, name}
+	end
+	
+	def get key
+		key.should! :be_a, String
+		row = @custom_metadata[:key => key]
+		return row ? row[:value] : nil
+	end
+	
+	def put key, value
+		key.should! :be_a, String
+		value.should! :be_a, String
+		
+		@custom_metadata.filter(:key => key).delete
+		@custom_metadata << {:key => key, :value => value}
+	end
+	
+	protected 
+	def initialize_db
+		@db.create_table :metadata do
+			column :key, :text
+			column :value, :text
+			primary_key :key
+#			index :key
+		end				
+		
+		@db.create_table :custom_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/Repository/StreamID.rb

@@ -0,0 +1,20 @@
+class StreamID
+	attr_reader :sid
+	def initialize id = nil
+		@sid = id
+	end
+	
+	def == other
+		return false unless other.respond_to? :sid
+		@sid == other.sid
+	end
+	
+	def eql? other
+		return false unless self.class == other.class
+		@sid == other.sid
+	end
+	
+	def hash		
+		return @sid.hash
+	end		
+end

data/lib/ObjectModel/Repository/StreamStorage.rb

@@ -0,0 +1,121 @@
+class StreamStorage
+	STREAMS = "streams"
+	
+	def initialize name, basedir, buffer_size = 8192
+		@buffer_size = buffer_size
+		raise "Invalid directory '#{basedir}'!" unless File.exist? basedir           
+		@path = File.join(basedir.gsub("\\", '/'), name.to_s)
+		
+		Dir.mkdir @path unless File.exist? @path						
+		Dir.mkdir File.join(@path, STREAMS) unless File.exist? File.join(@path, STREAMS)                
+	end        
+	
+	def clear
+		FileUtils.rm Dir.glob(File.join(@path, STREAMS, "*.dat"))		
+	end
+	
+	def strip_id id
+		id.sid
+	end
+	
+	def metadata_put id, metadata
+		id = strip_id(id)
+		metafile_name = File.join(@path, STREAMS, "#{id.to_s}.met")
+		File.open(metafile_name, "wb") do |datafile|			
+			datafile.write YAML.dump(metadata)
+		end						
+	end
+	
+	def metadata_read id
+		id = strip_id(id)
+		begin
+			File.open(File.join(@path, STREAMS, "#{id.to_s}.met"), "rb") do |file|
+				return YAML.load(file.read)
+			end
+		rescue Exception => e
+			if e.message =~ /No such file or directory/
+				raise RuntimeError, "The Metadata with id '#{id}' not exist!", caller
+			else
+				raise e
+			end
+		end
+	end
+	
+	def stream_put id, data = nil, &block		
+		id = strip_id(id)
+		datafile_name = File.join(@path, STREAMS, "#{id.to_s}.dat")
+		File.open(datafile_name, "wb") do |datafile|
+			if block
+				block.call datafile
+			elsif data
+				datafile.write data
+			else
+				raise "Data is not supplied!"
+			end				
+		end		
+	end
+	
+	def stream_put_each id, stream
+		stream_put id do |out|
+			while part = stream.read(@buffer_size)
+				out.write part
+			end
+		end		
+	end
+	
+	def stream_read id, &block
+		id = strip_id(id)
+		begin
+			File.open(File.join(@path, STREAMS, "#{id.to_s}.dat"), "rb") do |file|
+				if block
+					block.call file
+				else
+					return file.read
+				end
+			end
+		rescue Exception => e
+			if e.message =~ /No such file or directory/
+				raise RuntimeError, "The Stream with id '#{id}' has been deleted!", caller
+			else
+				raise e
+			end
+		end
+	end
+	
+	def stream_read_each id, &block
+		stream_read id do |f|
+			while part = f.read(@buffer_size)
+				block.call part
+			end
+		end
+	end
+	
+	def stream_size id
+		id = strip_id(id)
+		name = File.join(@path, STREAMS, "#{id.to_s}.dat")		
+		raise RuntimeError, "The Stream with id '#{id}' has been deleted!", caller unless File.exist? name
+		File.size(name)
+	end
+	
+	def size
+		Dir.glob(File.join(@path, STREAMS, "*.dat")).size 
+	end
+	
+	def delete id
+		id = strip_id(id)
+		name = File.join(@path, STREAMS, "#{id.to_s}.dat")		
+		File.delete name if File.exist? name
+		
+		name = File.join(@path, STREAMS, "#{id.to_s}.met")		
+		File.delete name if File.exist? name
+	end
+	
+	def list_of_ids
+		Dir.glob(File.join(@path, STREAMS, "*.dat")).collect{|name| File.basename(name, ".dat")}
+	end
+	
+	def self.delete name, basedir
+		path = File.join(basedir, name.to_s)
+		FileUtils.rm_rf path if File.exist? path
+	end	
+end

data/lib/ObjectModel/Repository/SystemListener.rb

@@ -0,0 +1,143 @@
+class SystemListener
+	def initialize transaction
+		@transaction = transaction
+		@deleted_parents = {}
+	end
+	
+	def before_attribute_update entity, name, new, old
+		name.should! :be_a, Symbol
+		AnEntity::EntityType.validate_attribute entity, name, new, old
+	end
+	
+	def before_name_update entity, new, old		
+		return if new == old
+		raise_without_self "name '#{new}' should be a String!", ObjectModel unless new.is_a? String
+		raise_without_self "name '#{new}' shouldn't be Emtpy!", ObjectModel if new.empty?
+		raise_without_self "name '#{new}' should not include '/' Symbol!", ObjectModel if new.include? '/'
+		
+		check_name_uniquity entity, new		
+	end
+	
+	def after_new_parent entity, old_parent
+		check_name_uniquity entity, entity.name
+	end
+	
+	def after_delete_parent entity, old_parent
+		check_name_uniquity entity, entity.name
+	end
+	
+	def before_commit entities
+		entities.should! :be_a, Array
+		entities.each do |e|
+			AnEntity::EntityType.validate_entity e
+		end
+	end
+	
+	def after_new entity
+		AnEntity::EntityType.custom_initialization entity
+	end
+	
+	def before_new_child entity, name, child				
+		raise_without_self "Child should be Entity or Nil (#{child})!", ObjectModel unless child.is_a?(Entity) or child == nil
+		raise_without_self "Forbiden to add self as Child!", ObjectModel if child == entity
+		raise_without_self "Forbiden to add the same Child twice!", ObjectModel if child.parent == entity
+		
+		name.should! :be_a, Symbol
+		
+		old_parent = child.parent
+		if old_parent != nil # :move
+			AnEntity::EntityType.delete_from_parent child, old_parent			
+			@transaction.event_processor.fire_before child, :move, entity, old_parent
+			@transaction.copies[entity.entity_id].moved!
+		end
+		
+		@transaction.event_processor.fire_before child, :new_parent, entity				
+		
+		child._parent = entity
+		
+		@transaction.event_processor.fire_after child, :new_parent, old_parent				
+		
+		if old_parent != nil # :move
+			@transaction.event_processor.fire_after child, :move, entity, old_parent
+		end		
+	end
+	
+	def before_delete_child entity, name, child
+		child.should! :be_a, Entity
+		entity.should! :be_a, Entity
+		name.should! :be_a, Symbol		
+		
+		@transaction.event_processor.fire_before child, :delete_parent, entity
+		child._parent = nil
+		@transaction.event_processor.fire_after child, :delete_parent, entity
+	end
+	
+	def before_delete entity		
+		if entity.name_get == "child2"
+			copy = @transaction.copies[entity.entity_id]
+			
+			parent = entity.parent
+			parent.should! :be_a, [Entity, NilClass]
+			
+			@transaction.deleted_entities[entity.entity_id] = entity
+			
+			AnEntity::EntityType.delete_all_references_to @transaction, entity
+			AnEntity::EntityType.delete_from_parent entity, parent if parent		
+			AnEntity::EntityType.delete_all_children entity
+			return
+		end
+		
+		copy = @transaction.copies[entity.entity_id]
+		copy.should_not! :deleted?
+		
+		parent = entity.parent
+		parent.should! :be_a, [Entity, NilClass]
+		
+		@transaction.deleted_entities[entity.entity_id] = entity
+		
+		AnEntity::EntityType.delete_all_references_to @transaction, entity
+		AnEntity::EntityType.delete_from_parent entity, parent if parent		
+		AnEntity::EntityType.delete_all_children entity
+	end		
+	
+	def before_delete_reference entity, name, reference
+		entity.should! :be_a, Entity
+		reference.should! :be_a, Entity
+		name.should! :be_a, Symbol
+		
+		@transaction.event_processor.fire_before reference, :delete_referrer, entity
+		
+		AnEntity::EntityType.delete_backreference @transaction, entity, reference		
+		
+		@transaction.event_processor.fire_after reference, :delete_referrer, entity
+	end
+	
+	def before_new_reference entity, name, reference
+		entity.should! :be_a, Entity
+		reference.should! :be_a, Entity
+		name.should! :be_a, Symbol
+		
+		@transaction.event_processor.fire_before reference, :new_referrer, entity
+		
+		AnEntity::EntityType.new_backreference @transaction, entity, reference		
+		
+		@transaction.event_processor.fire_after reference, :new_referrer, entity
+	end	
+	
+	protected
+	def check_name_uniquity entity, name				
+		# Uniquity In Transaction Scope
+		the_same = @transaction.new_entities.values.any? do |e|
+			next if e == entity
+			e.name == name and e.parent == entity.parent
+		end		
+		
+		# Uniquitey In Database		
+		parent = entity.parent
+		parent_path = parent != nil ? parent.path + "/" : ""
+		absolute_path = "#{parent_path}#{name}"		
+		the_same ||= @transaction.repository.include? absolute_path
+		
+		raise_without_self "Not unique name '#{name}' (Parent '#{entity.parent}')!", ObjectModel if the_same
+	end
+end