active-orient 0.6 → 0.42

data/lib/base_properties.rb

@@ -3,82 +3,85 @@ require 'active_support/concern'
 require 'active_support/hash_with_indifferent_access'
 
 module ActiveOrient
+
+  # Module adds prop Macro and
   module BaseProperties
     extend ActiveSupport::Concern
 
-# Default presentation of ActiveOrient::Model-Objects
+    ### Instance methods
 
+    # Default presentation
     def to_human
       "<#{self.class.to_s.demodulize}: " + content_attributes.map do |attr, value|
-	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('"' , ' ')
+        "#{attr}: #{value}" unless value.nil?
+      end.compact.sort.join(' ') + ">"
     end
 
-# Comparison support
-
-    def content_attributes  # :nodoc:
+    # 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)
+                                  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  # :nodoc:
+    # Update nil attributes from given Hash or model
+    def update_missing attrs
       attrs = attrs.content_attributes unless attrs.kind_of?(Hash)
-      attrs.each{|attr, val| send "#{attr}=", val if send(attr).blank?}
+
+      attrs.each { |attr, val| send "#{attr}=", val if send(attr).blank? }
       self # for chaining
     end
 
-# Default Model comparison
-
-    def == other  # :nodoc:
+    # Default Model comparison
+    def == other
       case other
       when String # Probably a link or a rid
-        "##{rid}" == other || rid == other
+        link == other || rid == other
       when  ActiveOrient::Model
-	      rid == other.rid
+	link == other.link
       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 => DateTime.now }
+      {:created_at => Time.now,
+       :updated_at => Time.now,
+       }
     end
 
-    def set_attribute_defaults # :nodoc:
+    def set_attribute_defaults
       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   # :nodoc: 
+      def self.prop *properties
         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  # :nodoc:
+      def self.define_property names, body
         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}="
@@ -86,7 +89,8 @@ module ActiveOrient
         end
       end
 
-      def self.define_property_methods name, body={}   # :nodoc:
+      def self.define_property_methods name, body={}
+        #p name, body
         case body
         when '' # default getter and setter
           define_property_methods name
@@ -98,24 +102,23 @@ 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
 
@@ -129,15 +132,16 @@ 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/model.rb

@@ -0,0 +1,468 @@
+class String
+  def to_or
+    "'#{self}'"
+  end
+end
+
+class Numeric
+  def to_or
+   "#{self.to_s}"  
+  end
+end
+module ActiveOrient
+
+#require 'base'
+#require 'base_properties'
+
+class Model < ActiveOrient::Base
+   include BaseProperties
+
+   mattr_accessor :orientdb
+   mattr_accessor :logger
+=begin
+orientdb_class is used to instantiate a ActiveOrient:Model:{class} by providing its name
+todo: implement object-inherence
+=end
+   def self.orientdb_class name: 
+     klass = Class.new( self )
+     name =  name.to_s.camelize
+     if self.send :const_defined?, name 
+       retrieved_class =  self.send :const_get, name
+     else
+	new_class = self.send :const_set  , name , klass
+	new_class.orientdb =  orientdb
+	new_class # return_value
+     end
+   rescue NameError => e
+    logger.error "Model:: Class name cannot be initialized"
+    puts "klass: #{klass.inspect}"
+    puts "name : #{name.inspect}" 
+    puts e.inspect
+   end
+
+=begin
+ActiveOrient::Model.autoload_object "#00:00"
+either retrieves the object from the rid_store or loads it from the DB
+
+the rid_store is updated!
+
+to_do: fetch for version in the db and load the object if a change is detected
+=end
+   def self.autoload_object   link
+#     puts "autoload_object #{link}"
+     link_cluster_and_record = link[1,link.size].split(':').map &:to_i
+     @@rid_store[link_cluster_and_record].presence || orientdb.get_document( link ) 
+   end
+
+  
+  def self.superClass
+    orientdb.get_classes( 'name', 'superClass').detect{|x| x["name"].downcase ==  new.class.to_s.downcase.split(':')[-1].to_s
+    }['superClass']
+  end
+
+  def to_orient
+    link
+  end
+  def from_orient
+    self
+  end
+=begin
+Returns just the name of the Class 
+=end
+   def classname
+      self.class.to_s.split(':')[-1]
+   end
+
+=begin
+If a Rest::Model-Object is included in a HashWidhtIndifferentAccess-Object, only the link is stored
+=end
+     def nested_under_indifferent_access # :nodoc:
+                link
+     end
+
+   # hard-coded orientdb-columns
+#     prop :cluster, :version, :record, :fieldtypes
+  
+#   def default_attributes
+#     super.merge cluster: 0
+#     super.merge version: 0
+#     super.merge record: 0
+#   end
+   def riid # :nodoc:
+       [ @metadata[ :cluster ] , @metadata[ :record ] ]
+   end
+=begin
+rid is used in the where-part of sql-queries
+=end
+   def rid
+       "#{@metadata[ :cluster ]}:#{@metadata[ :record ]}"
+   rescue 
+       "0:0"
+   end
+=begin
+link is used in any sql-commands 
+eg .  update #link set  ...
+=end
+   def link
+     "##{rid}"
+   end
+
+
+#   def method_missing method, *args, &b
+#     property=  orientdb.get_class_properties( classname )['properties'].detect{|x| x.has_value?  method.to_s }
+#     puts "method_missing::property"
+#     puts property.inspect
+#     if property.present?
+#       if property['type'] == 'LINKSET'
+#	 attributes[method] = OrientSupport::Array.new( self )
+#       else
+#	 attributes[method] = ''
+#       end
+#     else
+#	 raise NoMethodError
+#     end
+#   end
+=begin 
+Queries the database and fetches the count of datasets
+
+Any parameter that qualifies a database-query is suppoerted
+(see method get_documents)
+=end
+   def self.count **args
+     orientdb.count_documents from: self , **args
+   end
+=begin
+Creates a new Instance of the Class with the applied attributes
+and returns the freshly instantiated Object
+=end
+
+   def self.create properties = {}
+      orientdb.create_or_update_document  self, set: properties
+   end
+
+   def self.update_or_create set: {}, where:{} ,**args, &b
+	orientdb.update_or_create_documents self , set: set,  where: where , **args , &b  
+
+   end
+
+   # historic method
+   def self.new_document attributes: {}  # :nodoc:
+      orientdb.create_or_update_document  self, set: attributes
+   end
+=begin
+Create a Property in the Schema of the Class
+ :call-seq: 
+  self.create_property(  field (required) , type: 'string', linked_class: nil, index: nil)  do
+	      index
+	end
+=end
+
+   def self.get_properties 
+     object =  orientdb.get_class_properties self
+     {:properties => object['properties'] , :indexes => object['indexes'] }
+   end
+
+   def self.create_property field, **keyword_arguments, &b
+     orientdb.create_property  self, field,  **keyword_arguments, &b
+   end
+
+   def self.create_properties argument_hash, &b
+     orientdb.create_properties self, argument_hash, &b
+   end
+
+   def self.create_link name, class_name
+     orientdb.create_property self,  name, type: 'link', linked_class: class_name
+   end
+   def self.create_linkset name, class_name
+     orientdb.create_property self,  name, type: 'linkset', linked_class: class_name
+   end
+=begin
+Only if the Class inherents from »E« 
+Instantiate a new Edge betwen two Vertices
+
+Parameter: unique: (true)  In case of an existing Edge just update its Properties. 
+The parameters »from« and »to« can take a list of model-records. Then subsequent edges are created.
+ :call-seq: 
+  self.create_edge from: , to: , unique: false, attributes:{} 
+=end
+   def self.create_edge **keyword_arguments 
+      o=orientdb.nexus_edge  self, **keyword_arguments 
+      [:from,:to].each{|y| keyword_arguments[y].is_a?(Array) ? keyword_arguments[y].each( &:reload! ):  keyword_arguments[y].reload! }
+      o  # return_value
+   end
+=begin
+QueryDatabase sends the Query, direct to the database.
+The result is not nessessary a Object of self. 
+However, if the query does not return an array of Active::Model-Objects, then the entries become self
+=end
+   def self.query_database query, set_from: true
+     query.from self if set_from && query.is_a?( OrientSupport::OrientQuery ) && query.from.nil? 
+     sql_cmd = -> (command) { { type: "cmd", language: "sql", command: command } }
+     orientdb.execute( self.to_s.split(':')[-1] ) do
+       [ sql_cmd[ query.to_s ] ]
+     end 
+   end
+   def query  q 
+     a= ActiveOrient::Query.new 
+     a.queries << q
+     a.execute_queries
+   end
+=begin
+Parameter projection:
+
+»select« is a method of enumeration, we use  »projection:« to specify anything between »select« and »from«
+in the query-string.	
+
+   projection:  a_string -->  inserts the sting as it appears
+		an OrientSupport::OrientQuery-Object --> performs a sub-query and uses the result for further querying though the given parameters.
+		
+		[ a, b, c ] -->  "a , b , c " ( inserts a comma-separated list )
+
+		{ a: b, "sum(x) "=>  f } --> "a as b, sum(x) as f"  (renames properties and uses functions )
+Parameter distinct: 
+  
+Performs a Query like » select distinct( property ) [ as property ] from ...«
+
+  distinct: :property               -->  the result is mapped to the property »distinct«.
+  
+            [ :property ]           -->  the result replaces the property
+	    
+	    { property: :some_name} -->  the result is mapped to ModelInstance.some_name
+
+Parameter Order
+
+Sorts the result-set.
+
+If new properties are introduced via select:, distinct: etc
+
+Sorting takes place on these properties
+
+  order: :property
+         { property: asc, property: desc }
+         [property, property, ..  ]  ( orderdirection is 'asc' )
+
+
+Further supported Parameter:
+    group_by
+    skip
+    limit
+    unwind
+
+see orientdb- documentation (https://orientdb.com/docs/last/SQL-Query.html)
+
+Parameter  query:
+Instead of providing the parameter, the OrientSupport::OrientQuery can build and
+tested before the method-call. The OrientQuery-Object can be provided with the query-parameter
+i.e.
+  q=  OrientSupport::OrientQuery.new
+  TestModel =  r.open_class 'test_model'
+  q.from TestModel
+  q.where { name: 'Thomas' }
+
+  count= TestModel.count query:q
+  q.limit 10
+  0.step(count,10) do |x|
+    q.skip = x
+    puts TestModel.get_documents( query: q ).map{|x| x.adress }.join('\t')
+  end
+prints a Table with 10 columns.
+=end
+
+   def self.get_documents **args 
+     orientdb.get_documents( from: self,  **args ){ self }
+    
+   end
+=begin
+Performs a query on the Class and returns an Array of ActiveOrient:Model-Records.
+
+Example:
+  Log =  r.open_class 'Log'
+  Log.where priority: 'high'
+  --> submited database-request: query/hc_database/sql/select from Log where priority = 'high'/-1
+  => [ #<ActiveOrient::Model::Log:0x0000000480f7d8 @metadata={ ... },  ... ]
+
+
+=end
+def self.where attributes =  {}
+  q = OrientSupport::OrientQuery.new where: attributes
+  query_database q 
+end
+=begin
+
+removes the Model-Instance from the database
+
+returns true (successfully deleted) or false  ( obj not deleted)
+=end
+   def delete
+     
+     r= if is_edge?
+       # returns the count of deleted edges
+       orientdb.delete_edge rid
+     else
+      orientdb.delete_document  rid
+     end
+     ActiveOrient::Base.remove_riid self if r # removes the obj from the rid_store
+     r # true or false 
+   end
+=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
+   # get enables loading of datasets if a link is followed
+   #  model_class.all.first.link.get
+   def self.get rid
+     orientdb.get_document rid
+   end
+   def self.all
+     orientdb.get_documents from: self 
+end
+   def self.first where: {}
+     orientdb.get_documents(  from: self, where: where, limit: 1).pop
+   end
+
+   def self.last where: {}
+     #  debug:: orientdb.get_documents( self, order: { "@rid" => 'desc' }, limit: 1 ){ |x| puts x }.pop
+     orientdb.get_documents( from: self, where: where,  order: { "@rid" => 'desc' }, limit: 1 ).pop
+   end
+=begin
+Convient update of the dataset by calling sql-patch
+The 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: {}
+      attributes.merge!( set ) if set.present?
+      result= orientdb.patch_document(rid) do
+       attributes.merge( { '@version' => @metadata[ :version ], '@class' => @metadata[ :class ] } )
+     end
+#     returns a new instance of ActiveOrient::Model
+     reload! ActiveOrient::Model.orientdb_class(name: classname).new(  JSON.parse( result ))  
+     # instantiate object, update rid_store and reassign to self
+
+   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 = orientdb.get_document( link) if updated_dataset.nil?
+     @metadata[:version]= updated_dataset.version
+     attributes = updated_dataset.attributes
+     self  # return_value  (otherwise only the attributes would be returned)
+   end
+
+   def remove_item_from_property array, item=nil
+     logger.progname = 'ActiveOrient::Model#RemoveItemFromProperty'
+     execute_array =  Array.new
+     return unless attributes.has_key? array
+     remove_execute_array = -> (it) do
+       case it
+       when ActiveOrient::Model
+	 execute_array <<  {type: "cmd", language: "sql", command: "update #{link} remove #{array} = #{it.link}"} 
+       when String
+	  execute_array <<  {type: "cmd", language: "sql", command: "update #{link} remove #{array} = '#{it}'"} 
+       when Numeric
+	  execute_array <<  {type: "cmd", language: "sql", command: "update #{link} remove #{array} = #{it}"} 
+       else
+	 logger.error { "Only Basic Formats supported . Cannot Serialize #{it.class} this way" }
+	 logger.error { "Try to load the array from the DB, modify it and update the hole record" }
+       end
+     end
+
+     if block_given?
+       items =  yield
+       items.each{|x| remove_execute_array[x];   self.attributes[array].delete( x ) }
+     elsif item.present?
+       remove_execute_array[item]
+       a= attributes; a.delete item
+       self.attributes[array].delete( item )
+     end
+     orientdb.execute do
+       execute_array
+     end
+     reload!
+
+   rescue RestClient::InternalServerError => e
+     logger.error " Could not remove item in #{array} "
+     logger.error e.inspect
+   end
+
+=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
+
+  to_do:  use "<<" to add the item to the property
+=end
+   def add_item_to_property array, item=nil
+     logger.progname = 'ActiveOrient::Model#AddItem2Property'
+     execute_array =  Array.new
+     self.attributes[array] = Array.new unless attributes[array].present?
+     add_2_execute_array = -> (it) do
+       case it
+       when ActiveOrient::Model
+	 execute_array <<  {type: "cmd", language: "sql", command: "update #{link} add #{array} = #{it.link}"} 
+       when String
+	  execute_array <<  {type: "cmd", language: "sql", command: "update #{link} add #{array} = '#{it}'"} 
+       when Numeric
+	  execute_array <<  {type: "cmd", language: "sql", command: "update #{link} add #{array} = #{it}"} 
+       else
+	 logger.error { "Only Basic Formats supported . Cannot Serialize #{it.class} this way" }
+	 logger.error { "Try to load the array from the DB, modify it and update the hole record" }
+       end
+     end
+
+     if block_given?
+       items =  yield
+       items.each{|x| add_2_execute_array[x];   self.attributes[array] << x }
+     elsif item.present?
+       add_2_execute_array[item]
+       self.attributes[array] << item
+     end
+     orientdb.execute do
+       execute_array
+     end
+     reload!
+
+   rescue RestClient::InternalServerError => e
+     logger.error " Duplicate found in #{array} "
+     logger.error e.inspect
+   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
+=begin
+Convient method for updating a linkset-property
+its called via
+  model.update_linkset( linkset-property, Object_to_be_linked_to )
+or
+  mode.update_linkset( linkset-property ) do
+      Array_of_Objects_to_be_linked_to
+  end
+=end
+
+#private 
+   def version
+     @metadata[ :version ] 
+   end
+
+end # class
+
+end # module