active-orient 0.4 → 0.5

data/lib/base.rb

@@ -1,7 +1,8 @@
 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
     extend ActiveModel::Naming
     extend ActiveModel::Callbacks
@@ -9,212 +10,213 @@ module  ActiveOrient
     include ActiveModel::Serialization
     include ActiveModel::Serializers::Xml
     include ActiveModel::Serializers::JSON
-    
+    include OrientDB
+
+    define_model_callbacks :initialize
 
-    ##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
+# ActiveRecord::Base callback API mocks
+    define_model_callbacks :initialize, :only => :after
+    mattr_accessor :logger
 
-    def self.display_riid
+# Used to read the metadata
+    attr_reader :metadata
+
+=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
       @@rid_store
     end
-    def self.remove_riid obj
-      @@rid_store[obj.riid]=nil 
+
+    def self.remove_rid obj
+      @@rid_store.delete obj.rid
     end
-    def self.get_riid link
 
+    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
+
+    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
       else
-	obj # no rid-value: just return the obj
+	      obj # no rid-value: just return the obj
       end
     end
 
+    def document
+      @d
+    end
 
-    define_model_callbacks :initialize
+=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
 
-    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
+    def initialize attributes = {}, opts = {}
+      logger.progname = "ActiveOrient::Base#initialize"
       @metadata = HashWithIndifferentAccess.new
-#      @edges = HashWithIndifferentAccess.new
-    
+      @d =  nil
       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}" }
+	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
 	    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 
-	  @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 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
 	  end
 
-	  #### edges -- remove in_ and out_ and de-capitalize the remaining edge
-	  if @metadata[ :fieldTypes ].present? && (@metadata[ :fieldTypes ] =~ /=g/)
+	  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('_')
+	      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}" }  
-
+	      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
 	      end
 	    end
 	  end
 	end
-
-
-	  self.attributes = attributes # set_attribute_defaults is now after_init callback
-	end
-	ActiveOrient::Base.store_riid self
+	self.attributes = attributes # set_attribute_defaults is now after_init callback
       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
 
-    # ActiveModel-style read/write_attribute accessors
-    # Here we define the autoload mechanism
-    def [] key
+=begin
+  ActiveModel-style read/write_attribute accessors
+  Autoload mechanism and data conversion are defined in the method "from_orient" of each class
+=end
 
-      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  }
+    def [] key
+      iv = attributes[key.to_sym]
+      if @metadata[:fieldTypes].present? && @metadata[:fieldTypes].include?(key.to_s+"=t")
+	iv =~ /00:00:00/ ? Date.parse(iv) : DateTime.parse(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
+	iv.from_orient
       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
-=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
+      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 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
-      
+			       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(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
     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
-
-    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}", [])
-      end
-    end
-
-    def self.find *args
-      []
-    end
-
-    ### ActiveRecord::Base callback API mocks
-
-    define_model_callbacks :initialize, :only => :after
-
-    ### ActiveRecord::Base misc
+# 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}", [])
+#      end
+#    end
+#
+#    def self.find *args
+#      []
+#    end
+#
+# ActiveRecord::Base misc
 
     def self.serialize *properties
     end
 
   end # Model
-end # module 
+end # module

data/lib/base_properties.rb

@@ -3,83 +3,83 @@ require 'active_support/concern'
 require 'active_support/hash_with_indifferent_access'
 
 module ActiveOrient
-
-  # Module adds prop Macro and
   module BaseProperties
     extend ActiveSupport::Concern
 
-    ### Instance methods
+# Default presentation of ActiveOrient::Model-Objects
 
-    # Default presentation
     def to_human
       "<#{self.class.to_s.demodulize}: " + content_attributes.map do |attr, value|
-        "#{attr}: #{value}" unless value.nil?
-      end.compact.sort.join(' ') + ">"
+	v= case value
+	   when ActiveOrient::Model
+	     "< #{self.class.to_.demodulize} : #{value.rrid} >"
+	   else
+	     value.from_orient
+	   end
+        "%s : %s" % [ attr, v]  unless v.nil?
+      end.compact.sort.join(', ') + ">".gsub('"' , ' ')
     end
 
-    # Comparison support
-    def content_attributes
+# Comparison support
+
+    def content_attributes  # :nodoc:
       HashWithIndifferentAccess[attributes.reject do |(attr, _)|
-                                  attr.to_s =~ /(_count)\z/ ||
-                                    [:created_at, :updated_at, :type,
-                                     :id, :order_id, :contract_id].include?(attr.to_sym)
+        attr.to_s =~ /(_count)\z/ || [:created_at, :updated_at, :type, :id, :order_id, :contract_id].include?(attr.to_sym)
       end]
     end
 
-    # Update nil attributes from given Hash or model
-    def update_missing attrs
-      attrs = attrs.content_attributes unless attrs.kind_of?(Hash)
+# Update nil attributes from given Hash or model
 
-      attrs.each { |attr, val| send "#{attr}=", val if send(attr).blank? }
+    def update_missing attrs  # :nodoc:
+      attrs = attrs.content_attributes unless attrs.kind_of?(Hash)
+      attrs.each{|attr, val| send "#{attr}=", val if send(attr).blank?}
       self # for chaining
     end
 
-    # Default Model comparison
-    def == other
+# Default Model comparison
+
+    def == other  # :nodoc:
       case other
       when String # Probably a link or a rid
-        link == other || rid == other
+        "##{rid}" == other || rid == other
+      when  ActiveOrient::Model
+	      rid == other.rid
       else
-        content_attributes.keys.inject(true) { |res, key|
-          res && other.respond_to?(key) && (send(key) == other.send(key)) }
+        content_attributes.keys.inject(true){ |res, key|
+          res && other.respond_to?(key) && (send(key) == other.send(key))
+        }
       end
     end
 
-    ### Default attributes support
+# Default attributes support
 
     def default_attributes
       {:created_at => Time.now,
-       :updated_at => Time.now,
-       }
+       :updated_at => Time.now}
     end
 
-    def set_attribute_defaults
+    def set_attribute_defaults # :nodoc:
       default_attributes.each do |key, val|
         self.send("#{key}=", val) if self.send(key).nil?
-        # self.send("#{key}=", val) if self[key].nil? # Problems with association defaults
       end
     end
 
     included do
-
       after_initialize :set_attribute_defaults
 
-      ### Class macros
+# Class macros
 
-      def self.prop *properties
+      def self.prop *properties   # :nodoc: 
         prop_hash = properties.last.is_a?(Hash) ? properties.pop : {}
-
         properties.each { |names| define_property names, nil }
         prop_hash.each { |names, type| define_property names, type }
       end
 
-      def self.define_property names, body
+      def self.define_property names, body  # :nodoc:
         aliases = [names].flatten
         name = aliases.shift
         instance_eval do
-
           define_property_methods name, body
-
           aliases.each do |ali|
             alias_method "#{ali}", name
             alias_method "#{ali}=", "#{name}="
@@ -87,8 +87,7 @@ module ActiveOrient
         end
       end
 
-      def self.define_property_methods name, body={}
-        #p name, body
+      def self.define_property_methods name, body={}   # :nodoc:
         case body
         when '' # default getter and setter
           define_property_methods name
@@ -100,23 +99,24 @@ module ActiveOrient
             :validate => body[2]
 
         when Hash # recursion base case
+#	  puts "NAME: "+name.to_S
+#		     puts "BODY::"+body.inspect
           getter = case # Define getter
           when body[:get].respond_to?(:call)
             body[:get]
           when body[:get]
-            proc { self[name].send "to_#{body[:get]}" }
+            proc{self[name].send "to_#{body[:get]}"}
           else
-            proc { self[name] }
+            proc{self[name]}
           end
           define_method name, &getter if getter
-
           setter = case # Define setter
           when body[:set].respond_to?(:call)
             body[:set]
           when body[:set]
-            proc { |value| self[name] = value.send "to_#{body[:set]}" }
+            proc{|value| self[name] = value.send "to_#{body[:set]}"}
           else
-            proc { |value| self[name] = value } # p name, value;
+            proc{|value| self[name] = value} # p name, value;
           end
           define_method "#{name}=", &setter if setter
 
@@ -130,14 +130,13 @@ module ActiveOrient
             end
           end
 
-          # TODO define self[:name] accessors for :virtual and :flag properties
+# todo define self[:name] accessors for :virtual and :flag properties
 
         else # setter given
           define_property_methods name, :set => body, :get => body
         end
       end
 
-      # Timestamps in lightweight models
       unless defined?(ActiveRecord::Base) && ancestors.include?(ActiveRecord::Base)
         prop :created_at, :updated_at
       end