active-orient 0.4 → 0.5

data/lib/model/the_record.rb

@@ -0,0 +1,310 @@
+module ModelRecord
+  ############### RECORD FUNCTIONS ###############
+
+  ############# GET #############
+
+  def from_orient
+    self
+  end
+
+  # Returns just the name of the Class
+
+  def self.classname  # :nodoc:
+    self.class.to_s.split(':')[-1]
+  end
+
+  #
+  # Obtain the RID of the Record  (format: "00:00")
+  #
+
+  def rid
+    begin
+      "#{@metadata[:cluster]}:#{@metadata[:record]}"
+    rescue
+      "0:0"
+    end
+  end
+=begin
+The extended representation of rid (format "#00:00" )
+=end
+  def rrid
+    "#" + rid
+  end
+  alias to_orient rrid
+
+  def to_or
+    rrid
+  end
+=begin
+Query uses the current model-record  as origin of the query
+It sends the OrientSupport::OrientQuery directly to the database and returns a 
+ActiveOrient::Model-Object or an Array of Model-Objects as result. 
+
+=end
+
+  def query query
+    
+    sql_cmd = -> (command) {{ type: "cmd", language: "sql", command: command }}
+    orientdb.execute do
+      sql_cmd[query.to_s]
+    end
+  end
+
+=begin
+queries the database starting with the current model-record.
+
+Returns the result-set, ie. a Query-Object which contains links to the addressed records.
+
+=end
+  def find attributes =  {}
+    q = OrientSupport::OrientQuery.new from: self, where: attributes
+    query q
+  end
+ 
+  # Get the version of the object
+  def version  # :nodoc:
+    if document.present?
+      document.version
+    else
+      @metadata[:version]
+    end
+  end
+
+  def version= version  # :nodoc:
+    @metadata[:version] = version
+  end
+
+  def increment_version # :nodoc: 
+    @metadata[:version] += 1
+  end
+  ########### UPDATE PROPERTY ############
+
+=begin
+  Convient method for populating embedded- or linkset-properties
+  In both cases an array/a collection is stored in the database.
+  Its called via
+    model.add_item_to_property(linkset- or embedded property, Object_to_be_linked_to\)
+  or
+    mode.add_items_to_property( linkset- or embedded property ) do
+      Array_of_Objects_to_be_linked_to
+      #(actually, the objects must inherent from ActiveOrient::Model, Numeric, String)
+    end
+  
+  The method is aliased by "<<" i.e
+    model.array << new_item
+=end
+
+  def update_item_property method, array, item = nil, &ba # :nodoc:
+ #   begin
+      logger.progname = 'ActiveOrient::Model#UpdateItemToProperty'
+      #self.attributes[array] = OrientSupport::Array.new(self) unless attributes[array].present?
+      self.attributes[array] = Array.new unless attributes[array].present?
+
+      items = if item.present?
+		item.is_a?(Array)? item : [item]  
+	      elsif block_given?
+		yield
+	      end
+      db.manipulate_relation self, method, array, items
+      #rescue RestClient::InternalServerError => e
+#	logger.error{"Duplicate found in #{array}"}
+#	logger.error{e.inspect}
+#      end
+    end
+=begin
+Add Items to a linked or embedded class
+Parameter
+
+  array : the name of the property to work on
+  item :  what to add (optional)
+  block:  has to provide an array of elements to add to the property
+
+example:
+
+   add_item_to_property :second_list do
+       (0 .. 9).map do | s |
+               SecondList.create label: s
+       end  
+   end
+   adds 10 Elements to the property.
+
+
+   The method returns the model record itself. Thus nested initialisations are possible:
+   
+       ORD.create_classes([:base, :first_list, :second_list ]){ "V" }
+       ORD.create_property :base, :first_list,  type: :linklist, linkedClass: :first_list
+       ORD.create_property :base, :label, index: :unique
+       ORD.create_property :first_list,  :second_list , type: :linklist, linkedClass: :second_list
+       ORD.create_vertex_class :log
+       (0 .. 9).each do | b |
+          base= Base.create label: b, first_list: []
+          base.add_item_to_property :first_list do
+             (0 .. 9).map do | f |
+                first = FirstList.create label: f, second_list: []
+	         base.add_item_to_property :first_list , first
+	         first.add_item_to_property :second_list do
+	           (0 .. 9).map{| s |  SecondList.create label: s }
+	         end    # add item  second_list
+	      end      # 0..9 -> f
+	   end        # add item  first_list
+	end        # 0..9 -> b
+
+
+Record#AddItemToProperty shines with its feature to specify records to insert in a block.
+If only single Items are to insert, use
+  model_record.linklist << item 
+
+=end
+
+  def add_item_to_property array, item = nil, &b
+    items = block_given? ? yield : nil
+    update_item_property "ADD", array, item, &b
+    self # return_value
+  end
+#  alias add_items_to_property add_item_to_property
+  ## historical aliases
+#  alias update_linkset  add_item_to_property
+#  alias update_embedded  add_item_to_property
+
+  def set_item_to_property array, item = nil, &b
+    update_item_property "SET", array, item, &b
+  end
+
+  def remove_item_from_property array, item = nil, &b
+    update_item_property "REMOVE", array, item, &b
+    if block_given?
+        items =  yield
+        items.each{|x| self.attributes[array].delete(x)}
+    elsif item.present?
+        a = attributes
+        a.delete item
+        self.attributes[array].delete(item)
+      end
+    self # return_value
+  end
+
+  ############# DELETE ###########
+
+#  Removes the Model-Instance from the databasea
+#  todo:  overloaded in vertex and edge
+
+def remove 
+  orientdb.delete_record self
+  ActiveOrient::Base.remove_rid self ##if is_edge? # removes the obj from the rid_store
+end
+
+## delete works for any model-class
+## it calls delete_record and does not check for dependencies
+alias delete remove
+
+########### UPDATE ############
+
+=begin
+  Convient update of the dataset by calling sql-patch
+
+  Previously changed attributes are saved to the database.
+  With the optional :set argument ad-hoc attributes can be defined
+    obj = ActiveOrient::Model::Contracts.first
+    obj.name =  'new_name'
+    obj.update set: { yesterdays_event: 35 }
+=end
+
+  def update set: {}
+    logger.progname = 'ActiveOrient::Model#Update'
+    self.attributes.merge!(set) if set.present?
+    self.attributes['updated_at'] =  Time.new
+    updated_dataset = db.update self, attributes, @metadata[:version]
+    # if the updated dataset changed, drop the changes made siently
+    if updated_dataset.is_a? ActiveOrient::Model
+    self.version =  updated_dataset.version
+    updated_dataset # return_value
+    else
+    logger.error("Version Conflict: reloading database values")
+    reload!
+    end
+
+  end
+  ########## SAVE   ############
+ 
+=begin
+Saves the record either
+
+* by calling update  or
+* by creating the record
+
+=end
+def save
+  if rid.rid?
+    update
+  else
+     db_object=  DB.create_record  self, attributes: attributes 
+     @metadata[:cluster], @metadata[:record] = db_object.rid[0,db_object.rid.size].split(':').map( &:to_i)
+     reload! db_object
+  end
+end
+
+=begin
+  Overwrite the attributes with Database-Contents (or attributes provided by the updated_dataset.model-instance)
+=end
+
+  def reload! updated_dataset = nil
+    updated_dataset = db.get_record(rid) if updated_dataset.nil?
+    @metadata[:version] = updated_dataset.version
+    attributes = updated_dataset.attributes
+    self  # return_value  (otherwise only the attributes would be returned)
+  end
+
+  ########## CHECK PROPERTY ########
+
+=begin
+  An Edge is defined
+  * when inherented from the superclass »E» (formal definition)
+  * if it has an in- and an out property
+
+  Actually we just check the second term as we trust the constuctor to work properly
+=end
+
+  def is_edge?
+    attributes.keys.include?('in') && attributes.keys.include?('out')
+  end
+
+=begin
+How to handle other calls
+
+* if  attribute is specified, display it
+* if  attribute= is specify, assign to the known property or create a new one
+
+=end
+  def method_missing *args
+    # if the first entry of the parameter-array is a known attribute
+    # proceed with the assignment
+    if args.size == 1
+      attributes.keys.include?( args.first.to_s ) ? attributes[args.first] : nil
+    elsif args[0][-1] == "=" 
+      if args.size == 2
+	if rid.rid? 
+	  update set:{ args[0][0..-2] => args.last }
+	else
+	  self.attributes[ args[0][0..-2]  ] = args.last
+	end
+      else
+	update set: {args[0][0..-2] => args[1 .. -1] } if rid.rid?
+      end
+    else
+      raise NameError
+    end
+  end
+  # rescue NameError => e
+  #   logger.progname = 'ActiveOrient::Model#MethodMissing'
+  #   if args.size == 1
+  #     logger.error{"Unknown Attribute: #{args.first} "}
+  #   else
+  #     logger.error{"Unknown Method: #{args.map{|x| x.to_s}.join(" / ")} "}
+  #   end
+  #   puts "Method Missing: Args: #{args.inspect}"
+  #   print e.backtrace.join("\n")
+  #   raise
+#end
+
+
+end

data/lib/model/vertex.rb

@@ -0,0 +1,32 @@
+class V   < ActiveOrient::Model
+  ## link to the library-class
+  # create 
+  # seems not to be nessesary as its identically to the universal create
+
+ 
+  # to do
+
+  # def delete
+  # delete an edge (as class method) 
+  # and 
+  # def remove
+  # delete an edge (as instance method)
+  
+  def edges kind=:all  # :all, :in, :out 
+    expression = case kind
+		 when :all
+		   /^in|^out/ 
+		 when :in
+		   /^in/ 
+		 when :out
+		   /^out/ 
+    end
+    edges = attributes.keys.find_all{ |x| x =~  expression }
+    edges.map{|x| attributes[x]}.flatten
+  end
+
+  def remove
+    db.delete_vertex self
+  end
+
+end

data/lib/orient.rb

@@ -1,98 +1,161 @@
 module OrientSupport
-=begin 
-This Module fences specialized ruby objects 
-=end
+
+# This Module fences specialized Ruby objects
 
   class Array < Array
-    include Support
-=begin
-Initialisation method stores the modelinstance in @orient.
+    include OrientSupport::Support
+    mattr_accessor :logger
 
-Further a list of array-elements is expected, which are forwarded (as Array) to Array 
+=begin
+  Initialisation method stores the model-instance to work on  in @orient.
+  The keyword_parameter "work_on" holds the record to work_ion.
+  Ihe second argument is the array to work with
 
+  If instead of a model-instance the model-class is provided, a new model-instance is created and returned
+  Its up to the caller to save the new instance in the database 
 
+  Further a list of array-elements is expected, which are forwarded (as Array) to Array
 =end
-    def initialize modelinstance, *args
-      @orient =  modelinstance
-      super args
-      @name = modelinstance.attributes.key(self)
-    
+
+    def initialize work_on:, work_with: 
+      @orient = work_on.class == Class ? work_on.new : work_on
+      super work_with
+      @name = @orient.attributes.key(self)
+    #  puts "ORIENT: #{@orient.inspect} "
+      @name =  yield if @name.nil? && block_given?
+    #  puts "NAME: #{@name.inspect}"
+    #  puts "SELF: #{self.inspect}"
     end
 
+    def record
+      @orient
+    end
+=begin
+Append the argument to the Array, changes the Array itself.
+
+The change is transmitted to the database immediately
+=end
     def << arg
-       @orient.add_item_to_property( @name,  arg ) if @name.present?
+#      print "\n <<---> #{@name}, #{arg} <--- \n"
+      if @name.present?
+	@orient.add_item_to_property(@name, arg)
+      end
       super
     end
 
 =begin
-Updating of single items
+  Updating of single items
 
-this only works if the hole embedded Array is previosly loaded into the ruby-array. 
+  This only works if the hole embedded Array is previously loaded into the Ruby-array.
 =end
-    
+
     def []= key, value
       super
-      @orient.update set: {  @name => self } if @name.present?
+      @orient.update set: {@name => self} if @name.present?
     end
 
     def [] *arg
-    #  puts "[] ARG: #{arg.inspect}"
-    #  arg.each{|u| puts "[] #{u.inspect} : #{u.class} " }
       super
-
     end
 
     def delete_at *pos
-      if @name.present? 
-       delete self[*pos]
+      if @name.present?
+        delete self[*pos]
       else
-	super
+	      super
       end
-       #       old version: works only if the hole array is loaded into memory
-#       self[*pos]=nil
-#      @orient.update set:{ @name => self.compact }
     end
 
     def delete_if
       if @name.present?
-      delete *self.map{|y|  y if yield(y) }.compact  # if the block returns true then delete the item
+        delete *self.map{|y| y if yield(y)}.compact  # if the block returns true then delete the item
       else
-	super
+	      super
       end
     end
 
     def delete *item
-      @orient.remove_item_from_property( @name ) {  item  } if @name.present?
+      @orient.remove_item_from_property(@name){item} if @name.present?
     end
 
+    ## just works with Hashes as parameters
     def where *item
-      where_string = item.map{|m| where_string =  compose_where m }.join( ' and ' )
-      query = "select from ( select expand( #{@name} ) from #{@orient.classname})  #{where_string} "
-      puts query
-      @orient.query query
-
+      where_string = item.map{|m| where_string = compose_where m}.join(' and ')
+       subquery= OrientSupport::OrientQuery.new from: @orient, projection: "expand( #{@name})"
+       q= OrientSupport::OrientQuery.new from: subquery, where: item
+#      query = "SELECT FROM ( SELECT EXPAND( #{@name} ) FROM #{@orient.classname})  #{where_string} "
+     # puts q.compose
+     #  sql_cmd = -> (command) {{ type: "cmd", language: "sql", command: command }}
+    #  @orient.orientdb.execute do
+#	  sql_cmd[query.to_s]
+#      end
+       @orient.query q 
     end
 
     def method_missing *args
-      map{|x| x.send args.first }
+      begin
+        map{|x| x.send args.first}
+      rescue NoMethodError => e
+        logger.progname = "OrientSupport::Array#MethodMissing"
+        logger.error{"Undefined method: #{e.message}"}
+      end
     end
-  end
-  class LinkMap < OrientSupport::Array
 
+  end #Class
+
+  class LinkMap < OrientSupport::Array
     def []= arg
     end
-  end 
-
-#
-#  class Hash < Hash_with_indifferent_access
-#    # additional and overlayed methods for Hash-Objects in OrientDB
-#    def initialize modelinstance, *args
-#      @orient =  modelinstance
-#      super args
-#      @name = modelinstance.attributes.key(self)
-#
+  end  #Class
+
+
+
+
+  class Hash  < HashWithIndifferentAccess
+    include OrientSupport::Support
+    def initialize modelinstance, args
+      @orient = modelinstance
+      super args.from_orient
+      # @name is the property of @orient to work on
+      @name = modelinstance.attributes.key(self)
+#      puts "ORIENT: #{@orient.inspect} "
+      @name =  yield if @name.nil? && block_given?
+#      puts "NAME: #{@name.inspect}"
+#      puts "SELF: #{self.inspect}"
+    end
+
+
+    def []=  key, value
+      puts " i will handle this in the future"
+    #@orient.attributes[key] = value
+	
+#	r = (@orient.query  "update #{@orient.rid} put #{@name} = #{key.to_orient}, #{value.to_orient} RETURN AFTER @this").pop
+	super key, value
+	@orient.update set:{ @name => self}
+#	@orient = @orient.class(@orient.rid){r} if r.is_a? ActiveOrient::Model
+#	 self[ key ]= value
+#	 puts self.inspect 
+	#@orient[@name]=self.merge  key => value
+	#
+    end
+
+    def delete key
+      super key
+      @orient.update set:{ @name => self}
+    end
+
+    def delete_if &b
+      super &b
+      @orient.update set:{ @name => self}
+
+    end
+
+#    def << 
+  
+
+#    def to_orient
+#     self
 #    end
-#
-#  end
 
-end
+  end
+end #Module