active-orient 0.4 → 0.80

data/examples/streets.rb

@@ -1,6 +1,7 @@
 =begin
-Streets Example
+---> The Streets Example does not work as the structure of external data used changed! 
 
+Streets Example
 
 We load german cities from wikipedia and parse the document for cities and countries(states).
 Further we load a collection of popular streetnames from a web-side called »strassen-in-deutschland«
@@ -15,115 +16,118 @@ At last we print the connected cities.
 module DataImport
   def read_german_street_names
     doc = Nokogiri::HTML(open('http://www.strassen-in-deutschland.de/die-haeufigsten-strassennamen-in-deutschland.html'))
-    strassen = doc.css('#strassen-in-deutschland_main a' ) # identified via css-inspector in browser
+    strassen = doc.css("td[data-header='Straßenname: '] a") # identified via css-inspector in browser
     # search for the css and include only links, then display the text-part
     strassen.children.map( &:to_s )[3..-1]  # omit the first three (strassen in deutschland, straßenverzeichnis, straßen)
   end
 
-  def read_german_cities_from_wikipedia 
-    # we extract <li> -elements and use the text until "(" 
+  def read_german_cities_from_wikipedia
+    # we extract <li> -elements and use the text until "("
     #doc.xpath("//li").at(80)
-    # => #<Nokogiri::XML::Element:0x1ba551c name="li" children=[#<Nokogiri::XML::Element:0x1ba533c name="a" attributes=[#<Nokogiri::XML::Attr:0x1ba52d8 name="href" value="/wiki/Angerm%C3%BCnde">, #<Nokogiri::XML::Attr:0x1ba52c4 name="title" value="Angermünde">] children=[#<Nokogiri::XML::Text:0x1ba4c84 "Angermünde">]>, #<Nokogiri::XML::Text:0x1ba4ae0 " (Brandenburg)">]> 
+    # => #<Nokogiri::XML::Element:0x1ba551c name="li" children=[#<Nokogiri::XML::Element:0x1ba533c name="a" attributes=[#<Nokogiri::XML::Attr:0x1ba52d8 name="href" value="/wiki/Angerm%C3%BCnde">, #<Nokogiri::XML::Attr:0x1ba52c4 name="title" value="Angermünde">] children=[#<Nokogiri::XML::Text:0x1ba4c84 "Angermünde">]>, #<Nokogiri::XML::Text:0x1ba4ae0 " (Brandenburg)">]>
 
     doc = Nokogiri::HTML(open('https://en.wikipedia.org/wiki/List_of_cities_and_towns_in_Germany'))
+    print doc
     doc.xpath("//li").map{|x| x.text[0 .. x.text.index('(')-2] if x.text.index('(').present? }.compact
   end
 
-  def read_german_cities_and_states_fom_wikipedia
+  def read_german_cities_and_states_from_wikipedia
     doc =
-      Nokogiri::HTML(open('https://en.wikipedia.org/wiki/List_of_cities_and_towns_in_Germany'))
-    doc.xpath("//li").map do |x| 
-      if x.text.index('(').present? 
-	[ x.text[0 .. x.text.index('(')-2] , x.text[ x.text.index('(')+1 .. x.text.index(')')-1] ]
+    Nokogiri::HTML(open('https://en.wikipedia.org/wiki/List_of_cities_and_towns_in_Germany'))
+    doc.xpath("//li").map do |x|
+      if x.text.index('(').present?
+        [ x.text[0 .. x.text.index('(')-2] , x.text[ x.text.index('(')+1 .. x.text.index(')')-1] ]
       end
     end.compact
-  end 
+  end
 
 end # module
 
- class StreetExample
-
-   include  DataImport
-    def initialize db, rebuild: true
-      if rebuild
-	ActiveOrient::OrientDB.logger.progname = "StreetsExample#Initialize"
-	db.delete_class :state
-	db.delete_class :city
-	db.delete_class :street
-	db.delete_class :connects
-	db.create_vertex_class :state 
-	db.create_vertex_class :city
-	db.create_vertex_class :street
-	db.create_edge_class :connects
-	ActiveOrient::Model::State.create_property( :name, type: :string, index: :unique )
-	ActiveOrient::Model::City.create_properties(  { name: { type: :string },
-			    state: { type: :link, :linked_class => 'State' } } 
-			      ) do
-				{ citi_idx: :unique } 
-			      end
-	ActiveOrient::Model::Street.create_property :name , type: :string, index: :notunique 
-	ActiveOrient::Model::Connects.create_property :distance, type: :integer, index: :notunique 
-	ActiveOrient::OrientDB.logger.info { "Vertex- and Edge-Classes rebuilded" }
-      end
+class StreetExample
+
+  include  DataImport
+  def initialize db, rebuild: true
+    if rebuild
+      db.delete_class :State
+      db.delete_class :City
+      db.delete_class :Street
+      db.delete_class :CONNECTS
+      db.create_vertex_class :state, :city, :street
+      db.create_edge_class :CONNECTS
+      State.create_property( :name, type: :string, index: :unique )
+      City.create_properties(  { name: { type: :string },
+                                 state: { type: :link, :linked_class => 'State' } }
+                             ) do
+                   { citi_idx: :unique }
+                               end
+      Street.create_property :name , type: :string, index: :notunique
+      CONNECTS.create_property :distance, type: :integer, index: :notunique
+      logger.progname = "StreetsExample#Initialize"
+      logger.info { "Vertex- and Edge-Classes rebuilded" }
     end
+  end
 
 
-    def read_from_web
-      ActiveOrient::OrientDB.logger.progname = "StreetsExample#ReadFromWeb"
-      read_german_cities_and_states_fom_wikipedia.each do |city,state| 
-	state =  State.update_or_create( where: { name: state }).first
-	City.create name: city, state: state.link
-      end
-      ActiveOrient::OrientDB.logger.info { "#{City.count} Cities imported from Wikipedia " }
-
-      cities_rids =  City.all.map &:link
-      read_german_street_names.each_with_index do |street, i|
-	street_record =  Street.create name: street
-	count = i
-	cities =  Array.new
-	while  count < cities_rids.size && cities.size < 5 do
-	  cities << cities_rids[count] 
-	  count =  count + i 
-	end
-	C.create_edge :from => street_record,  :to => cities
+  def read_from_web
+    read_german_cities_and_states_from_wikipedia.each do |city,state|
+      state =  State.update_or_create( where: { name: state }).first
+      City.create name: city, state: "##{state.rid}"
+    end
+    logger.progname = "StreetsExample#ReadFromWeb"
+    logger.info { "#{City.count} Cities imported from Wikipedia " }
+
+    cities_rids =  City.all.map &:rid
+    read_german_street_names.each_with_index do |street, i|
+      street_record =  Street.create name: street
+      count = i
+      cities =  Array.new
+      while  count < cities_rids.size && cities.size < 5 do
+        cities << cities_rids[count]
+        count =  count + i
       end
-      ActiveOrient::OrientDB.logger.info { "#{C.count} Edges between Streets and Cities created " }
+      CONNECTS.create_edge :from => street_record,  :to => cities
     end
-  
-    def display_streets_per_state
-      State.all.each do |state|
-	streets= Street.all.map do |street |
-	  if street.connects.in.detect{|x| x.state == state }
-	    street.name + " verbindet " + street.connects.in.map( &:name ).join('; ')
-	  end
-	end.compact
-	unless streets.empty?
-	  puts "..................................."
-	  puts state.name
-	  puts "..................................."
-	  puts streets.join("\n")
-	end
+    logger.progname = "StreetsExample#ReadFromWeb"
+    logger.info { "#{CONNECTS.count} Edges between Streets and Cities created " }
+  end
+
+  def display_streets_per_state
+    State.all.each do |state|
+      streets= Street.all.map do |street |
+        if street.connects.in.detect{|x| x.state == state }
+          street.name + " connects " + street.connects.in.map( &:name ).join('; ')
+        end
+      end.compact
+      unless streets.empty?
+        puts "..................................."
+        puts state.name
+        puts "..................................."
+        puts streets.join("\n")
       end
     end
- end
+  end
+end
 
 if $0 == __FILE__
 
-require '../config/boot'
-require 'open-uri'
-require 'nokogiri'
-
-    ActiveOrient::OrientDB.default_server= { user: 'hctw', password: 'hc' }
-    r = ActiveOrient::OrientDB.new database: 'StreetTest'
-    ActiveOrient::OrientDB.logger.level = Logger::INFO
-    s= StreetExample.new r, rebuild:  true 
-      
-    City = r.open_class :city
-    State = r.open_class :state
-    Street = r.open_class :street
-    C = r.open_class :connects
-    
-    s.read_from_web if City.count.zero?
-    s.display_streets_per_state
+  require '../config/boot'
+  require 'open-uri'
+  require 'nokogiri'
+
+  ActiveOrient::OrientDB.default_server= { user: 'root', password: 'tretretre' }
+  r = ActiveOrient::OrientDB.new database: 'StreetTest'
+  ActiveOrient::OrientDB.logger.level = Logger::INFO
+  s= StreetExample.new r, rebuild:  true
+
+  def to_orient
+    #puts "here hash"
+    substitute_hash = Hash.new
+    keys.each{|k| substitute_hash[k] = self[k].to_orient}
+    substitute_hash
+  end
+
+
+  s.read_from_web if City.count.zero?
+  s.display_streets_per_state
 
 end

data/graphs.txt

@@ -0,0 +1,70 @@
+Graphen
+======
+
+Die Felder `in` und   `out` bündeln die Verknüpfungen zu anderen Vertices.
+
+Die Verknüpfungen erfolgen über `Edges`, die wiederum Eigenschaften haben. Zuerst sind die `Edges` Klassen und
+unterscheiden sich üder den Namen. Zusätzlich besteht Vererbung. 
+
+Beispielgraph
+    @db.create_vertex_class  :v1 
+    @db.create_class( :v2 ){ V1 } 
+		@db.create_edge_class "e1"
+		@db.create_class( :e2 ){ E1 }
+		@db.create_class( :e3 ){ E1 }
+
+		vertices =  (1..10).map{|y| V2.create node: y}
+		E2.create from: V1.create( item: 1  ), to: vertices
+
+    v1 = V.first.to_human => "<V1[#25:0]: out: {E2=>10}, item : 1>" 
+		v2 = V.last.to_human  => "<V2[#40:0]: in: {E2=>1}, node : 8>" 
+  
+Boardmittel von ActiveOrient
+----------------------------
+    
+##  Edges anlisten
+		
+	#### Nur Links
+		
+		v1.edges  => ["#49:0", "#50:0", "#51:0", "#52:0", "#53:0", "#54:0", "#55:0", "#56:0", "#49:1", "#50:1"]
+		v2.edges  => ["#56:0"] 
+
+
+	#### Auflösung der Objekte
+
+		v2.in.map &:to_human => ["<E2: in : #<V2:0x000000000397fcb8>, out : #<V1:0x0000000002ed0060>>"] 
+
+  ####  Verfügbare Methoden
+		v2.in      v2.in_e   v2.in_e2		v2.in_e2= 	v2.in_edges 
+
+
+  ### Selektive Auswahl
+
+	Beispiel: TimeGrid
+
+	Der Vertex hat folgende Struktur
+
+		t.to_human
+		 => "<Tag[82:8927]: in: {TG::DAY_OF=>1, TG::GRID_OF=>1}, out: {ML::L_OHLC=>1, TG::GRID_OF=>1}, value : 25>" 
+
+	dann listet t.detect_edges :out, /ml/ die Edges der ML-Klassen auf:
+	 
+		t.detect_edges( :out , /ml/).to_human
+		 => ["<L_OHLC[#151:16] -i-> #161:22 {  } -o-> #82:8927>"] 
+		
+
+	#### Node
+	
+	Ein Node ist ein direkt über eine Edge verbundener Vertex
+
+		 Q =  OrientSupport::OrientQuery
+	   s= Q.new projection: "expand( outE('e1').in[node <5])"
+		 s.from = '#25:0'
+		 s.to_s => select expand( outE('v1').in[node <5]) from #25:0 
+	
+	Aufruf in OrientQuery:  Q.node Edge_class, condition
+	
+	Fügt den Node in das Porjections-Array ein.
+  
+		 
+

data/lib/active-orient.rb

@@ -1,7 +1,79 @@
-require "support.rb"
-require "base.rb"
-require "base_properties.rb"
 
-require "model.rb"
-require "orient.rb"
-require "rest.rb"
+module OrientDB
+  UsingJava = RUBY_PLATFORM == 'java' ?  true : false
+  unless UsingJava
+   DocumentDatabase       = nil
+   DocumentDatabasePool   = nil
+   DocumentDatabasePooled = nil
+   GraphDatabase          = nil
+    OTraverse             = nil
+    Document              = nil
+    IndexType             = nil
+    OClassImpl            = nil
+    PropertyImpl          = nil
+    Schema                = nil
+    SchemaProxy           = nil
+    SchemaType            = nil
+    SQLCommand            = nil
+    SQLSynchQuery         = nil
+    User                  = nil
+    RemoteStorage         = nil
+    ServerAdmin           = nil
+    # defined in other.rb
+    #JavaDate		  
+    #RecordList            = nil
+   # RidBag		  = nil
+   # RecordSet             = nil
+  end
+end  # module OrientDB
+require 'active_model'
+#require 'active_model/serializers'
+require_relative "support/orientquery.rb"
+require_relative "support/conversions.rb"
+#require_relative "support/logging.rb"
+require_relative "support/errors.rb"
+require_relative "base.rb"
+require_relative "base_properties.rb"
+require_relative "support/orient.rb"
+#require_relative "query.rb"
+if OrientDB::UsingJava
+  require_relative 'java-api.rb'
+  end
+require_relative "orientdb_private.rb" # manage private functions
+require_relative "database_utils.rb" #common methods without rest.specific content
+require_relative "class_utils.rb" #common methods without rest.specific content
+require_relative "other.rb"
+require_relative "rest/rest.rb"
+require_relative "model/model.rb"
+require 'active_support/core_ext/string' # provides blank?, present?, presence etc
+require_relative 'init.rb'
+# create Base Classes
+
+require_relative "model/vertex.rb"
+require_relative "model/edge.rb"
+
+require_relative "railtie" if defined?(Rails)
+
+module  ActiveOrient
+mattr_accessor :database
+mattr_accessor :db_pool
+mattr_accessor :database_classes
+mattr_accessor :default_server
+
+## displays all allocated classes
+##
+## usage: 
+##  puts ActiveOrient::show_classes
+#
+#
+def self.show_classes
+
+ '-'* 45+"\n"+
+ "Database Class  ->  ActiveOrient ClassName\n"+
+ '-'* 45+"\n"+
+  ActiveOrient.database_classes.map{|x,y| "#{"%15s"% x} ->  #{y.to_s}" }.join("\n") + "\n"+
+ '-'* 45 + "\n"
+end
+
+end
+

data/lib/base.rb

@@ -1,220 +1,318 @@
 module  ActiveOrient
-  require 'active_model'
-  #
-  # Base class for tableless IB data Models, extends ActiveModel API
+
+
+# Base class for tableless IB data Models, extends ActiveModel API
+
   class Base
+#		include OrientSupport::Logging 
     extend ActiveModel::Naming
     extend ActiveModel::Callbacks
     include ActiveModel::Validations
     include ActiveModel::Serialization
-    include ActiveModel::Serializers::Xml
+#    include ActiveModel::Serializers::Xml
     include ActiveModel::Serializers::JSON
-    
+    include OrientDB
+    include Conversions   # mocking ActiveModel::Conversions
+
+		mattr_accessor :logger 
+
+    define_model_callbacks :initialize
+# ActiveRecord::Base callback API mocks
+    define_model_callbacks :initialize, :only => :after
 
-    ##Every Rest::Base-Object is stored in the @@rid_store
-    ## The Objects are just references to the @@rid_store.
-    ## any Change of the Object is thus synchonized to any allocated variable
-    #
-    @@rid_store =  Hash.new
+# Used to read the metadata
+    attr_reader :metadata
 
-    def self.display_riid
+=begin
+  Every Rest::Base-Object is stored in the @@rid_store
+  The Objects are just references to the @@rid_store.
+  Any Change of the Object is thus synchonized to any allocated variable.
+=end
+    @@rid_store = Hash.new
+		@@mutex = Mutex.new
+
+    def self.display_rid
       @@rid_store
     end
-    def self.remove_riid obj
-      @@rid_store[obj.riid]=nil 
-    end
-    def self.get_riid link
 
+=begin
+removes an Item from the cache
+
+obj has to provide a method #rid 
+
+thus a string or a Model-Object is accepted
+=end
+
+    def self.remove_rid obj
+			if obj &.rid.present?
+			@@mutex.synchronize do 
+				@@rid_store.delete obj.rid     
+			end
+			else
+				logger.error "Cache entry not removed: #{obj} "
+			end
+		end
+
+    def self.get_rid rid
+      rid =  rid[1..-1] if rid[0]=='#'
+      @@rid_store[rid] 
     end
-    def self.store_riid obj
-      if obj.rid.present? && obj.riid.all?{|x| x.present? && x>=0} # only positive values are stored
-	  ## return the presence of a stored object as true by the block
-	  ## the block is only executed if the presence is confirmed
-	  ##  Nothing is returned from the class-method
-	if @@rid_store[obj.riid].present? 
-	  yield  if block_given?  	    
-	end
-	 @@rid_store[obj.riid] = obj
-	 @@rid_store[obj.riid]  # return_value
-      else
-	obj # no rid-value: just return the obj
-      end
+
+    def self.reset_rid_store
+      @@rid_store = Hash.new
     end
 
+=begin
+Stores the obj in the cache.
 
-    define_model_callbacks :initialize
+If the cache-value exists, it is updated by the data provided in obj
+and the cached obj is returned
+  
+=end
+    def self.store_rid obj
+
+			@@mutex.synchronize do 
+				if obj.rid.present? && obj.rid.rid?
+					if @@rid_store[obj.rid].present?
+						@@rid_store[obj.rid].transfer_content from: obj
+					else
+						@@rid_store[obj.rid] =   obj
+					end
+					@@rid_store[obj.rid] 
+				else
+					obj 
+				end
+			end
+		end
+
+
+    # rails compatibility
+    # remap rid to id unless id is present
+#    def id
+#      attributes[:id].present? ?  attributes[:id] : rrid
+#    end
 
-    mattr_accessor :logger
-    # If a opts hash is given, keys are taken as attribute names, values as data.
-    # The model instance fields are then set automatically from the opts Hash.
-    def initialize attributes={}, opts={}
-      logger.progname= "ActiveOrient::Base#initialize"
-      #possible_link_array_candidates = link_candidates = Hash.new
-      @metadata = HashWithIndifferentAccess.new
-#      @edges = HashWithIndifferentAccess.new
-    
-      run_callbacks :initialize do
-#	puts "initialize::attributes: #{attributes.inspect}"
-
-	attributes.keys.each do | att |
-	  unless att[0] == "@"	    # @ identifies Metadata-attributes
-	    att =  att.to_sym if att.is_a?(String)    
-	    unless self.class.instance_methods.detect{|x| x == att }
-	      self.class.define_property att, nil 
-#	      logger.debug { "property #{att.to_s} assigned to #{self.class.to_s}" }
-	    else
-#	      logger.info{ "property #{att.to_s}  NOT assigned " }
-	    end
-	  end
-	end
-
-	if attributes['@type'] == 'd'  # document 
-	  @metadata[ :type    ] = attributes.delete '@type'
-	  @metadata[ :class   ] = attributes.delete '@class' 
-	  @metadata[ :version ] = attributes.delete '@version' 
-	  @metadata[ :fieldTypes ] = attributes.delete '@fieldTypes' 
-	  if attributes.has_key?( '@rid' )
-	    rid = attributes.delete '@rid' 
-	    cluster, record = rid[1,rid.size].split(':') 
-	    @metadata[ :cluster ] =  cluster.to_i
-	    @metadata[ :record ] = record.to_i
-	  end
-
-	  #### edges -- remove in_ and out_ and de-capitalize the remaining edge
-	  if @metadata[ :fieldTypes ].present? && (@metadata[ :fieldTypes ] =~ /=g/)
-	    edges = @metadata['fieldTypes'].split(',').find_all{|x| x=~/=g/}.map{|x| x.split('=').first}
-	    edges.each do |edge|
-	      operator, *base_edge =  edge.split('_')
-	      base_edge = base_edge.join('_')
-	      unless self.class.instance_methods.detect{|x| x == base_edge }
-		## define two methods: out_{Edge}/{in_Edge} -> edge. 
-		self.class.define_property base_edge, nil 
-		self.class.send :alias_method, base_edge.underscore, edge  #  
-#		logger.debug { "#{link}:: edge #{edge} assigned to #{self.class.to_s} and remaped to #{base_edge.underscore}" }  
-
-	      end
-	    end
-	  end
-	end
-
-
-	  self.attributes = attributes # set_attribute_defaults is now after_init callback
-	end
-	ActiveOrient::Base.store_riid self
-      end
 
-    # ActiveModel API (for serialization)
+=begin
+If a opts hash is given, keys are taken as attribute names, values as data.
+The model instance fields are then set automatically from the opts Hash.
+=end
+
+		def initialize attributes = {}, opts = {}
+			logger.progname = "ActiveOrient::Base#initialize"
+			@metadata = Hash.new # HashWithIndifferentAccess.new
+			@d =  nil if RUBY_PLATFORM == 'java' && attributes.is_a?( Document )
+			run_callbacks :initialize do
+				if RUBY_PLATFORM == 'java' && attributes.is_a?( Document )
+					@d = attributes
+					attributes =  @d.values
+					@metadata[:class]      = @d.class_name
+					@metadata[:version]    = @d.version
+					@metadata[:cluster], @metadata[:record] = @d.rid[1,@d.rid.size].split(':')
+					puts "Metadata:  #{@metadata}"
+				end
+
+				# transform $current to :current and $current.mgr to :mgr
+				 transformers = attributes.keys.map{|x|  [x, x[1..-1].split(".").last.to_sym] if x[0] == '$'}.compact
+				 # transformers:  [ [original key, modified key] , [] ]
+				 transformers.each do |a|
+					 attributes[a.last] = attributes[a.first]
+					 attributes.delete a.first
+				 end
+
+				attributes.keys.each do |att|
+					unless att[0] == "@" # @ identifies Metadata-attributes
+						unless self.class.instance_methods.detect{|x| x == att.to_sym}
+							self.class.define_property att.to_sym, nil
+						else
+							#logger.info{"Property #{att.to_s} NOT assigned"}
+						end
+					end
+				end
+				if attributes['@type'] == 'd'  # document via REST
+					@metadata[:type]       = attributes.delete '@type'
+					@metadata[:class]      = attributes.delete '@class'
+					@metadata[:version]    = attributes.delete '@version'
+					@metadata[:fieldTypes] = attributes.delete '@fieldTypes'
+					
+					if attributes.has_key?('@rid')
+						rid = attributes.delete '@rid'
+						cluster, record = rid[1 .. -1].split(':')
+						@metadata[:cluster] = cluster.to_i
+						@metadata[:record]  = record.to_i
+					end
+
+					if @metadata[:fieldTypes ].present? && (@metadata[:fieldTypes] =~ /=g/)
+						@metadata[:edges] = { :in => [], :out => [] }
+						edges = @metadata[:fieldTypes].split(',').find_all{|x| x=~/=g/}.map{|x| x.split('=').first}
+						#  puts "Detected EDGES: #{edges.inspect}"
+						edges.each do |edge|
+							operator, *base_edge = edge.split('_')
+							base_edge = base_edge.join('_')
+							@metadata[:edges][operator.to_sym] << base_edge
+						end
+						#    unless self.class.instance_methods.detect{|x| x == base_edge}
+						#      ## define two methods: out_{Edge}/in_{Edge} -> edge.
+						#      self.class.define_property base_edge, nil
+						#      allocate_edge_method = -> (edge)  do
+						#        unless (ee=db.get_db_superclass(edge)) == "E"
+						#          allocate_edge_method[ee]
+						#          self.class.send :alias_method, base_edge.underscore, edge
+						#      ## define inherented classes, tooa
+						#      
+
+						#    end
+						#  end
+					end
+				end
+				self.attributes = attributes # set_attribute_defaults is now after_init callback
+			end
+			#      puts "Storing #{self.rid} to rid-store"
+			#      ActiveOrient::Base.store_rid( self ) do | cache_obj|
+			#	 cache_obj.reload! self
+			#      end
+		end
+
+# ActiveModel API (for serialization)
+
+    def included_links
+      meta= Hash[ @metadata[:fieldTypes].split(',').map{|x| x.split '='} ]
+      meta.map{|x,y| x if y=='x'}.compact
+    end
 
     def attributes
-      @attributes ||= HashWithIndifferentAccess.new
+      @attributes ||= Hash.new # WithIndifferentAccess.new
     end
 
     def attributes= attrs
-      attrs.keys.each { |key| self.send("#{key}=", attrs[key]) }
+      attrs.keys.each{|key| self.send("#{key}=", attrs[key])}
     end
 
-    # ActiveModel-style read/write_attribute accessors
-    # Here we define the autoload mechanism
-    def [] key
-
-      iv= attributes[key.to_sym]
-  #    iv.from_orient unless iv.nil?
-      if  iv.is_a?(String) && iv.rid? #&& @metadata[:fieldTypes].present? && @metadata[:fieldTypes].include?( key.to_s+"=x" )
-     # puts "autoload: #{iv}"
-	ActiveOrient::Model.autoload_object  iv
-      elsif iv.is_a?(Array) # && @metadata[:fieldTypes].present? && @metadata[:fieldTypes].match( key.to_s+"=[znmgx]" )
-     # puts "autoload: #{iv.inspect}"
-	OrientSupport::Array.new self, *iv.map{|y| (y.is_a?(String) && y.rid?) ? ActiveOrient::Model.autoload_object(  y ) : y  }
-      else
-
-	iv
-      end
-    end
+		def my_metadata key: nil, symbol: nil
+			if @metadata[:fieldTypes].present?  
+				meta= Hash[ @metadata[:fieldTypes].split(',').map{|x| x.split '='} ]
+				if key.present?
+					meta[key.to_s]
+				elsif symbol.present?
+					meta.map{|x,y| x if y == symbol.to_s }.compact
+				else
+					meta
+				end
+			end
+		end
 
-    def update_attribute key, value
-      @attributes[key] = value
-    end
 =begin
-Here we define how the attributes are initialized 
-Key and val are set by the RestCliend
+  ActiveModel-style read/write_attribute accessors
+
+  Autoload mechanism and data conversion are defined in the method "from_orient" of each class
 =end
-    def []= key, val
-      val = val.rid if val.is_a? ActiveOrient::Model
-#      if val.is_a?(Array) # && @metadata[:fieldTypes].present? && @metadata[:fieldTypes].include?( key.to_s+"=n" )
-#	if @metadata[ :fieldTypes ] =~ /out=x,in=x/
-#	puts "VAL is a ARRAY"
-#	else
-#	  puts "METADATA: #{ @metadata[ :fieldTypes ]}  "
-#	end
-#	val# = val.map{|x|  if val.is_a? ActiveOrient::Model then val.rid else val end }
-#      end
-      attributes[key.to_sym] = case val
-	 when Array
-	   if  val.first.is_a?(Hash)
-	     v=val.map do |x| 
-	       if x.is_a?( Hash ) 
-		 HashWithIndifferentAccess.new(x)
-	       else
-		 x 
-	       end
-	     end
-	     OrientSupport::Array.new( self, *v )
-	   else
-	     OrientSupport::Array.new( self, *val )
-	   end
-	 when Hash
-	    HashWithIndifferentAccess.new(val) 
-	 else
-	   val
-	 end
-      
+
+		def [] key
+
+			iv = attributes[key]
+			if my_metadata( key: key) == "t"
+				# needed in case of 
+				#  obj.date =  {some-date}
+				#  --> perfrom an action on the date without saving prior
+				case iv
+				when String
+				iv =~ /00:00:00/ ? Date.parse(iv) : DateTime.parse(iv) 
+				when Date, DateTime
+			    iv
+				else
+				raise "incompatable type used: #{iv} (#{iv.class}) -- Date or DateTime required"	 
+				end
+			elsif my_metadata( key: key) == "x"
+				iv = ActiveOrient::Model.autoload_object iv
+			elsif iv.is_a? Array
+				OrientSupport::Array.new( work_on: self, work_with: iv.from_orient){ key.to_sym }
+			elsif iv.is_a? Hash
+#				if iv.keys.include?("@class" )
+#				ActiveOrient::Model.orientdb_class( name: iv["@class"] ).new iv
+#				else
+#					iv
+				OrientSupport::Hash.new( self, iv.from_orient){ key.to_sym }
+	#			end
+				#     elsif iv.is_a? RecordMap 
+				#      iv
+				#       puts "RecordSet detected"
+			else
+				iv.from_orient
+			end
+		end
+
+		def []= key, val
+			val = val.rid if val.is_a?( ActiveOrient::Model ) && val.rid.rid?
+			attributes[key.to_sym] = case val
+															 when Array
+																 if val.first.is_a?(Hash)
+																	 v = val.map{ |x| x }
+																	 OrientSupport::Array.new(work_on: self, work_with: v ){ key_to_sym }
+																 else
+																	 OrientSupport::Array.new(work_on: self, work_with: val ){ key_to_sym }
+																 end
+															 when Hash
+																 if val.keys.include?("@class" )
+																	 OrientSupport::Array.new( work_on: self, work_with: val.from_orient){ key.to_sym }
+																 else
+																	 OrientSupport::Hash.new( self, val  )
+																 end
+															 else
+																 val
+															 end
+		end
+
+    def update_attribute key, value
+      @attributes[key] = value
     end
 
-    def to_model
+    def to_model   # :nodoc:
       self
     end
 
+# Noop methods mocking ActiveRecord::Base macros
 
-
-    ### Noop methods mocking ActiveRecord::Base macros
-    
     def self.attr_protected *args
     end
 
     def self.attr_accessible *args
     end
 
-    ### ActiveRecord::Base association API mocks
-
-    def self.belongs_to model, *args
+# ActiveRecord::Base association API mocks
+#
+    def self.belongs_to model, *args # :nodoc:
       attr_accessor model
     end
-
-    def self.has_one model, *args
+#
+    def self.has_one model, *args   # :nodoc:
       attr_accessor model
     end
-
-    def self.has_many models, *args
+#
+    def self.has_many models, *args  # :nodoc:
       attr_accessor models
-
       define_method(models) do
-        self.instance_variable_get("@#{models}") ||
-          self.instance_variable_set("@#{models}", [])
+        self.instance_variable_get("@#{models}") || self.instance_variable_set("@#{models}", [])
       end
     end
-
-    def self.find *args
-      []
+#
+#    def self.find *args
+#      []
+#    end
+#
+=begin
+(Experimental)
+Exclude some properties from loading via get, reload!, get_document, get_record
+=end
+    def self.exclude_the_following_properties *args
+      puts "excluding #{args}"
+    @excluded =  (@excluded.is_a?( Array))?  @excluded + args : args
+      puts "#{self.inspect} --> excluded #{@excluded}"
     end
 
-    ### ActiveRecord::Base callback API mocks
-
-    define_model_callbacks :initialize, :only => :after
-
-    ### ActiveRecord::Base misc
-
-    def self.serialize *properties
+# ActiveRecord::Base misc
+    def self.serialize *properties # :nodoc:
     end
-
+# Enable lazy loading
+    ActiveSupport.run_load_hooks(:active_orient, self)
   end # Model
-end # module 
+end # module