active-orient 0.6 → 0.42

data/lib/active-orient.rb

@@ -1,59 +1,11 @@
+require "support.rb"
+require "base.rb"
+require "base_properties.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.rb"
-require_relative "base.rb"
-require_relative "base_properties.rb"
-require_relative "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/edge.rb"
-require_relative "model/vertex.rb"
-
-module  ActiveOrient
-mattr_accessor :database
-mattr_accessor :database_classes
-mattr_accessor :default_server
-
-
-
-end
+require "model.rb"
+require "orient.rb"
+require "rest.rb"
 
+logger =  Logger.new '/dev/stdout'
+ActiveOrient::Model.logger =  logger
+ActiveOrient::OrientDB.logger =  logger

data/lib/base.rb

@@ -1,255 +1,228 @@
 module  ActiveOrient
-
-
-# Base class for tableless IB data Models, extends ActiveModel API
-
+  require 'active_model'
+  #
+  # Base class for tableless IB data Models, extends ActiveModel API
   class Base
     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
-
-    define_model_callbacks :initialize
-
-# ActiveRecord::Base callback API mocks
-    define_model_callbacks :initialize, :only => :after
-    mattr_accessor :logger
+    
 
-# Used to read the metadata
-    attr_reader :metadata
+    ##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
 
-=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
-
-    def self.display_rid
+    def self.display_riid
       @@rid_store
     end
-
-    def self.remove_rid obj
-      @@rid_store.delete obj.rid
-    end
-
-    def self.get_rid rid
-      rid =  rid[1..-1] if rid[0]=='#'
-      @@rid_store[rid] 
+    def self.remove_riid obj
+      @@rid_store[obj.riid]=nil 
     end
+    def self.get_riid link
 
-    def self.reset_rid_store
-      @@rid_store = Hash.new
     end
-
-    def self.store_rid obj
-      if obj.rid.present? && obj.rid.rid?
-	  # 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.rid].present?
-	        yield if block_given?
-	      end
-	      @@rid_store[obj.rid] = obj
-	      @@rid_store[obj.rid]  # return_value
+    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
+	obj # no rid-value: just return the obj
       end
     end
 
-    def document
-      @d
-    end
 
-=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
+    define_model_callbacks :initialize
 
-    def initialize attributes = {}, opts = {}
-      logger.progname = "ActiveOrient::Base#initialize"
+    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
-      @d =  nil
+#      @edges = HashWithIndifferentAccess.new
+    
       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(':')
-
-
-
-	end
-	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
+#	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"}
+#	      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,rid.size].split(':')
-	    @metadata[:cluster] = cluster.to_i
-	    @metadata[:record]  = record.to_i
+	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
 
-	  if @metadata[:fieldTypes ].present? && (@metadata[:fieldTypes] =~ /=g/)
-	    @metadata[:edges] = { :in => [], :out => [] }
+	  #### 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}
-	  #  puts "Detected EDGES: #{edges.inspect}"
 	    edges.each do |edge|
-	      operator, *base_edge = edge.split('_')
+	      operator, *base_edge =  edge.split('_')
 	      base_edge = base_edge.join('_')
-	      @metadata[:edges][operator.to_sym] << base_edge
+	      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
-	  #    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
+
+
+	  self.attributes = attributes # set_attribute_defaults is now after_init callback
+	end
+	ActiveOrient::Base.store_riid self
       end
-      #      puts "Storing #{self.rid} to rid-store"
-      ActiveOrient::Base.store_rid self
-    end
 
-# ActiveModel API (for serialization)
+    # ActiveModel API (for serialization)
 
     def attributes
       @attributes ||= HashWithIndifferentAccess.new
     end
 
     def attributes= attrs
-      attrs.keys.each{|key| self.send("#{key}=", attrs[key])}
+      attrs.keys.each { |key| self.send("#{key}=", attrs[key]) }
     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
+    # 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
+
+	if  @metadata[:fieldTypes].present? && @metadata[:fieldTypes].include?( key.to_s+"=t" ) # time
+	  # switch between date and datetime representation of the date-object  
+	  iv =~ /00:00:00/ ? Date.parse( iv ) :   DateTime.parse( iv )
 	else
-	  meta
+	iv
 	end
       end
     end
 
+    def update_attribute key, value
+      @attributes[key] = value
+    end
 =begin
-  ActiveModel-style read/write_attribute accessors
-  Autoload mechanism and data conversion are defined in the method "from_orient" of each class
+Here we define how the attributes are initialized 
+Key and val are set by the RestCliend
 =end
-
-    def [] key
-      iv = attributes[key.to_sym]
-#      puts my_metadata( key: key) 
-       if my_metadata( key: key) == "t"
-#	puts "time detected"
-	iv =~ /00:00:00/ ? Date.parse(iv) : DateTime.parse(iv)
-      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
-	  OrientSupport::Hash.new( self, iv){ key.to_sym }
-#     elsif iv.is_a? RecordMap 
- #      iv
-#       puts "RecordSet detected"
-      else
-	iv.from_orient
-      end
-    end
-
     def []= key, val
-#      puts "here I am: #{key}, #{val}"
-      val = val.rid if val.is_a?( ActiveOrient::Model ) && val.rid.rid?
+      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
-#				 puts "I am an 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(work_on: self, work_with: v )
-				 else
-				   OrientSupport::Array.new(work_on: self, work_with: val )
-				 end
-			       when Hash
-				 HashWithIndifferentAccess.new(val)
-			       else
-				 val
-			       end
-    end
-
-    def update_attribute key, value
-      @attributes[key] = value
+	 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
+      
     end
 
     def to_model
       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
-#
+    ### ActiveRecord::Base association API mocks
+
     def self.belongs_to model, *args
       attr_accessor model
     end
-#
+
     def self.has_one model, *args
       attr_accessor model
     end
-#
+
     def self.has_many models, *args
       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
-#      []
-#    end
-#
-# ActiveRecord::Base misc
+
+    def self.find *args
+      []
+    end
+
+    ### ActiveRecord::Base callback API mocks
+
+    define_model_callbacks :initialize, :only => :after
+
+    ### ActiveRecord::Base misc
 
     def self.serialize *properties
     end
 
   end # Model
-end # module
+end # module