Method: ActiveOrient::OrientDB#create_classes

Defined in:
lib/rest.rb

#create_classes(classes) ⇒ Object

Creates classes and class-hierachies in OrientDB and in Ruby.

Takes an Array or a Hash as argument and returns an Array of successfull allocated Ruby-Classes

If the argument is an array, Basic-Classes are build.

Otherwise key/value pairs are assumend to follow this terminology

{ SuperClass => [ class, class, ...], SuperClass => [] , ... }



282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
 
# File 'lib/rest.rb', line 282

def create_classes classes
  # rebuild cashed classes-array
  # first the classes-string is camelized (this is used to allocate the ruby-class)
  # Then the database is queried for this string or the underscored string-variant 
  # the name-building process is independend from the method »class_name«
  database_classes requery: true
  consts = Array.new
  execute  transaction: false do 
    class_cmd = ->(s,n) do
 n = n.to_s.camelize
 consts << ActiveOrient::Model.orientdb_class( name: n)
 unless database_classes.include?(n) || database_classes.include?(n.underscore)
 { type: "cmd", language: 'sql', command:  "create class #{n} extends #{s}"  } 

 end 
    end  ## class_cmd
    
    if classes.is_a?(Array)
 classes.map do | n |
 n = n.to_s.camelize # capitalize
   consts << ActiveOrient::Model.orientdb_class( name: n)
   unless database_classes.include?( n ) || database_classes.include?(n.underscore)
    { type: "cmd", language: 'sql', command:  "create class #{n} " } 
   end
 end
    elsif classes.is_a?(Hash)
 classes.keys.map do | superclass | 
   items =  Array.new
   superClass =  superclass.to_s.camelize
   items <<  { type: "cmd", language: 'sql', command:  "create class #{superClass} abstract" }  unless  database_classes.flatten.include?( superClass ) || database_classes.flatten.include?( superClass.underscore ) 
   items << if classes[superclass].is_a?( String ) || classes[superclass].is_a?( Symbol )
    class_cmd[superClass, classes[superclass] ]
   elsif  classes[superclass].is_a?( Array )  
    classes[superclass].map{|n| class_cmd[superClass, n] }
   end 
   #puts items.flatten.map{|x| x[:command]}
   items  # returnvalue
 end.flatten 
    end.compact # erase nil-entries, in case the class is already allocated
  end
  # refresh cached class-informations
  database_classes requery: true
  # returns an array of allocated Constants/Classes
   consts
end