active-orient 0.42 → 0.79

data/lib/base_properties.rb

@@ -1,87 +1,96 @@
 require 'active_model'
 require 'active_support/concern'
-require 'active_support/hash_with_indifferent_access'
+#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} >"
+		 when OrientSupport::Array
+			 value.rrid #.to_human #.map(&:to_human).join("::")
+	   else
+	     value.from_orient
+	   end
+        "%s : %s" % [ attr, v]  unless v.nil?
+      end.compact.sort.join(', ') + ">".gsub('"' , ' ')
     end
 
-    # Comparison support
-    def content_attributes
-      HashWithIndifferentAccess[attributes.reject do |(attr, _)|
-                                  attr.to_s =~ /(_count)\z/  ||
-                                    [:created_at, :updated_at, :type,
-                                     :id, :order_id, :contract_id].include?(attr.to_sym)
+# Comparison support
+
+    def content_attributes  # :nodoc:
+#      HashWithIndifferentAccess[attributes.reject do |(attr, _)|
+      Hash[attributes.reject do |(attr, _)|
+        attr.to_s =~ /(_count)\z/ || attr.to_s =~ /^in_/ || attr.to_s =~ /^out_/ || [: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)
+# return a string ready to include as embedded document
+		def embedded
+			{ "@type" => 'd', "@class" => self.class.ref_name }
+			            .merge(content_attributes)
+			            .map{|y,x| z='';  z  <<  y.to_s << ': ' << x.to_or.to_s }.join(' ,')
+			
+		end
 
-      attrs.each { |attr, val| send "#{attr}=", val if send(attr).blank? }
+# Update nil attributes from given Hash or model
+
+    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
-	link == other.link
+	      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,
-       }
+			{}
+      #{:created_at => DateTime.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}="
@@ -89,8 +98,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
@@ -102,25 +110,26 @@ module ActiveOrient
             :validate => body[2]
 
         when Hash # recursion base case
-          getter = case # Define getter
-          when body[:get].respond_to?(:call)
-            body[:get]
-          when body[:get]
-            proc { self[name].send "to_#{body[:get]}" }
-          else
-            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]}" }
-          else
-            proc { |value| self[name] = value } # p name, value;
-          end
-          define_method "#{name}=", &setter if setter
+	#  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]}"}
+									else
+										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]}"}
+									else
+										proc{|value| self[name] = value} # p name, value;
+									end
+				 define_method "#{name}=", &setter if setter
 
           # Define validator(s)
           [body[:validate]].flatten.compact.each do |validator|
@@ -132,16 +141,15 @@ 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
+        prop :created_at #, :updated_at
       end
 
     end # included

data/lib/class_utils.rb

@@ -0,0 +1,226 @@
+module ClassUtils
+  # ClassUitils is included in Rest- and Java-Api-classes
+
+=begin
+  Returns a valid database-class name, nil if the class does not exists
+=end
+
+  def classname name_or_class  # :nodoc:
+    name = case  name_or_class
+	   when ActiveOrient::Model
+	     name_or_class.class.ref_name 
+	   when Class
+	     ActiveOrient.database_classes.key(name_or_class)
+	   else
+	     if ActiveOrient.database_classes.has_key?( name_or_class.to_s )
+	       name_or_class 
+	     else
+	       logger.progname =  'ClassUtils#Classname'
+	       logger.warn{ "Classname #{name_or_class.inspect} ://: #{name} not present in #{ActiveOrient.database}" }
+	       nil
+	     end
+	   end
+  end
+	def allocate_class_in_ruby db_classname, &b
+		# retrieve the superclass recursively
+
+		unless ActiveOrient.database_classes[ db_classname ].is_a? Class
+
+			s = get_db_superclass( db_classname )
+			superclass =  if s.present?     # get the superclass recusivly
+											allocate_class_in_ruby( s, &b ) 
+										else
+											ActiveOrient::Model
+										end
+			# superclass is nil, if allocate_class_in_ruby is recursivley
+			# called and the superclass was not established
+			if superclass.nil?
+				ActiveOrient.database_classes[ db_classname ] = "Superclass model file missing"
+				return
+			end
+			reduced_classname =  superclass.namespace_prefix.present? ? db_classname.split( superclass.namespace_prefix ).last :  db_classname
+			classname =  superclass.naming_convention(  reduced_classname )
+
+			the_class = if !( ActiveOrient::Model.namespace.send :const_defined?, classname, false )
+										ActiveOrient::Model.namespace.send( :const_set, classname, Class.new( superclass ) )
+									elsif ActiveOrient::Model.namespace.send( :const_get, classname).ancestors.include?( ActiveOrient::Model )
+										ActiveOrient::Model.namespace.send( :const_get, classname)
+									else
+										t= ActiveOrient::Model.send :const_set, classname, Class.new( superclass )
+										logger.warn{ "Unable to allocate class #{classname} in Namespace #{ActiveOrient::Model.namespace}"}
+										logger.warn{ "Allocation took place with namespace ActiveOrient::Model" }
+										t
+									end
+			the_class.ref_name = db_classname
+			keep_the_dataset = block_given? ? yield( the_class ) : true
+			if keep_the_dataset 
+				ActiveOrient.database_classes[db_classname] = the_class 
+				the_class.ref_name =  db_classname
+				the_class #  return the generated class
+			else
+				unless ["E","V"].include? classname  # never remove Base-Classes!
+					base_classname =  the_class.to_s.split("::").last.to_sym
+
+					if ActiveOrient::Model.namespace.send( :const_defined? , classname)
+						ActiveOrient::Model.namespace.send( :remove_const, classname )
+					else
+						ActiveOrient::Model.send( :remove_const, classname)
+					end
+				end
+				nil  # return-value
+			end
+		else
+			# return previosly allocated ruby-class
+			ActiveOrient.database_classes[db_classname] 
+		end
+	end
+
+=begin
+create a single class and provide properties as well
+
+   ORD.create_class( the_class_name as String or Symbol (nessesary) ,
+		    properties: a Hash with property- and Index-descriptions (optional)) do
+		    { superclass: The name of the superclass as String or Symbol , 
+		      abstract: true|false 
+		      } 
+		     end
+
+  or
+
+  ORD.create_class( class1, class2 ... ) { Superclass } 
+
+  ORD.create_class( class ) { {superclass: the_superclass_name, abstract: true_or_false } } 
+
+  ORD.create_class class
+
+=end
+	def create_class( *class_names, properties: nil, &b )
+
+
+		if block_given?
+			the_block =  yield
+			superclass, abstract = if the_block.is_a? Class
+															 [ the_block, nil ]
+														 elsif the_block.is_a?(String) || the_block.is_a?(Symbol)
+															 [ ActiveOrient.database_classes[the_block] , nil ]
+														 elsif the_block.is_a?(Hash)
+															 [ ActiveOrient.database_classes[the_block[:superclass]], 
+									ActiveOrient.database_classes[the_block[:abstract]] ]
+														 end
+		end
+		superclass =  superclass.presence ||  ActiveOrient::Model
+
+
+		r= class_names.map do | the_class_name |
+			the_class_name =  superclass.namespace_prefix + the_class_name.to_s 
+
+			## lookup the database_classes-Hash
+			if ActiveOrient.database_classes[the_class_name].is_a?(Class)
+				ActiveOrient.database_classes[the_class_name] 
+			else
+				if superclass =="" || superclass.ref_name == ""
+					create_this_class the_class_name 
+				else
+					create_this_class( the_class_name ) do
+						if the_block.is_a?(Hash) 
+							the_block[:superclass] = superclass.ref_name
+							the_block
+						else
+							{ superclass: superclass.ref_name }
+						end
+					end
+				end
+				database_classes  # update_class_array
+				create_properties( the_name , properties )  if properties.present?
+				allocate_class_in_ruby( the_class_name ) do |that_class| 
+					keep_the_dataset =  true
+				end
+			end
+		end
+		r.size==1 ? r.pop : r  # return a single class or an array of created classes
+	end
+
+=begin
+Creates one or more vertex-classes and allocates the provided properties to each class.
+
+  ORD.create_vertex_class :a
+  => A
+  ORD.create_vertex_class :a, :b, :c
+  => [A, B, C]
+=end
+
+  def create_vertex_class *name, properties: nil 
+    r= name.map{|n| create_class( n, properties: properties){ V } }
+    r.size == 1 ? r.pop : r
+  end
+=begin
+Creates one or more edge-classes and allocates the provided properties to each class.
+=end
+
+  def create_edge_class *name,  properties: nil
+    r = name.map{|n| create_class( n.to_s, properties: properties){ E  } }
+    r.size == 1 ? r.pop : r  # returns the created classes as array if multible classes are provided
+  end
+=begin
+
+creates a vertex
+
+=end
+  def create_vertex( o_class, attributes:{} )
+
+		begin
+			response = execute(transaction: false, tolerated_error_code: /found duplicated key/) do
+				"CREATE VERTEX #{classname(o_class)} CONTENT #{attributes.to_orient.to_json}"
+			end
+			if response.is_a?(Array) && response.size == 1
+				response.pop # RETURN_VALUE
+			else
+				response  # return value (the normal case)
+			end
+		rescue ArgumentError => e
+			puts "CreateVertex:ArgumentError "
+			puts e.inspect
+		end  # begin
+
+	end
+
+=begin
+Deletes the specified vertices and unloads referenced edges from the cache
+=end
+  def delete_vertex *vertex
+    create_command =  -> do
+      { type: "cmd",
+	  language: 'sql',
+	  command: "DELETE VERTEX #{vertex.map{|x| x.to_orient }.join(',')} "
+		      }
+      end
+
+    vertex.each{|v| v.edges.each{| e | remove_record_from_hash e} }
+    execute{ create_command[] }
+  end
+
+=begin
+Deletes the specified edges and unloads referenced vertices from the cache
+=end
+  def delete_edge *edge
+    create_command =  -> do
+      { type: "cmd",
+	  language: 'sql',
+	  command: "DELETE EDGE #{edge.map{|x| x.to_orient }.join(',')} "
+		      }
+      end
+
+    edge.each do |r|
+      [r.in, r.out].each{| e | remove_record_from_hash e}
+      remove_record_from_hash r
+    end
+    execute{ create_command[] }
+  end
+
+  private
+	def remove_record_from_hash r
+	  obj= ActiveOrient::Base.get_rid(r.rid) unless r.nil?
+	  ActiveOrient::Base.remove_rid( obj ) unless obj.nil?
+	end
+
+end # module

data/lib/database_utils.rb

@@ -0,0 +1,98 @@
+module DatabaseUtils
+=begin
+returns the classes set by OrientDB
+
+Parameter: 
+  abstract: true|false
+
+if abstract: true is given, only basic classes (Abstact-Classes) are returend
+=end
+	def system_classes abstract: false
+
+		basic=   [  "ORestricted", "OSchedule", "OTriggered", "OSequence"]
+		## "ORid" dropped in V2.2
+		extended = ["OIdentity","ORole",  "OUser", "OFunction", "_studio"]
+		v3 = ["OGeometryCollection", "OLineString", "OMultiLineString", "OMultiPoint", "OMultiPolygon",
+		"OPoint", "OPolygon", "ORectangle", "OShape"] ## added in Orentdb 3.0
+		if abstract
+			basic
+		else
+			basic + extended + v3
+		end
+	end
+=begin
+Returns the class_hierachy
+
+To fetch all Vertices:
+   class_hieararchy(base_class: 'V').flatten
+To fetch all Edges:
+   class_hierarchy(base_class: 'E').flatten
+--
+notice: 
+To retrieve the class hierarchy from Objects avoid calling `ORD.classname (obj)`,  because it depends on class_hierarchy.
+=end
+
+	def class_hierarchy base_class: '',  system_classes: nil
+		@actual_class_hash = get_classes('name', 'superClass') #if requery || @all_classes.blank?
+		fv = ->( s )	{ 	@actual_class_hash.find_all{|x| x['superClass']== s}.map{|v| v['name']} }
+		fx = ->( v )  {		fv[v.strip].map{|x| ar = fx[x]; ar.empty? ? x : [x, ar]} }
+		if system_classes.present?
+			fx[ base_class.to_s ]
+		else
+			fx[ base_class.to_s ] - system_classes()  - [ ["OIdentity", ["ORole", "OUser"]]] - [ ["OShape",["OGeometryCollection","OLineString", "OMultiLineString", "OMultiPoint", "OMultiPolygon", "OPoint", "OPolygon", "ORectangle"]  ] ]
+		end
+	end
+
+
+=begin
+Returns an array with all names of the classes of the database. Uses a cached version if possible.
+  
+Parameters: system_classes: false|true, requery: false|true
+=end
+
+  def database_classes system_classes: nil, requery: false
+    class_hierarchy system_classes: system_classes #requery: true
+    all_classes = get_classes('name').map(&:values).sort.flatten
+    all_user_classes =  all_classes - system_classes()
+
+    all_user_classes.each{|x| ActiveOrient.database_classes[x] = "unset" unless ActiveOrient.database_classes.has_key?(x) }
+    
+    ActiveOrient.database_classes.keys  # return an array of database-classnames
+  end
+
+=begin
+Service-Method for Model#OrientdbClass
+=end
+
+  def get_db_superclass name   #:nodoc:
+    @actual_class_hash = get_classes( 'name', 'superClass') if @actual_class_hash.nil? 
+   z= @actual_class_hash.find{|x,y|  x['name'] == name.to_s }
+   z['superClass'] unless z.nil?
+  end
+
+=begin
+preallocate classes reads any class from the  @classes-Array and allocates adequat Ruby-Objects
+=end
+	def preallocate_classes   from_model_dir= nil  # :nodoc:
+		# always scan for E+V model-file and include
+		[E,V].each{|y| y.require_model_file(from_model_dir) }
+
+		ActiveOrient.database_classes.each do | db_name, the_class |
+			allocate_class_in_ruby( db_name ) do |detected_class|
+			keep_the_dataset =  true
+			# keep the class if it is already noted in database_classes 
+		 if	![E,V].include?(detected_class) &&
+				!ActiveOrient.database_classes.key( detected_class) && 
+				!detected_class.require_model_file(from_model_dir) &&
+			  !ActiveOrient::Model.keep_models_without_file  
+	
+				logger.info{ "#{detected_class.name} -->  Class NOT allocated"}
+				ActiveOrient.database_classes[ detected_class.ref_name ] = "no model file"
+				keep_the_dataset = false 
+			end
+			keep_the_dataset # return_value
+		end  # block
+		end  # each iteration
+	end	# def
+
+end # module