active-orient 0.4 → 0.80

data/lib/rest/rest.rb

@@ -0,0 +1,120 @@
+require_relative "read.rb" # manage get
+require_relative "create.rb" # manage create
+require_relative "change.rb" # manage update
+require_relative "operations.rb" # manage count, functions and execute
+require_relative "delete.rb" # manage delete
+require_relative "../support/logging"
+#require 'cgi'
+require 'rest-client'
+require 'pond'
+
+module ActiveOrient
+
+=begin
+OrientDB points to an OrientDB-Database.
+The communication is based on the OrientDB-REST-API.
+
+Its usually initialised through ActiveOrient::Init.connect
+
+=end
+
+  class OrientDB
+    include OrientSupport::Support
+    include OrientSupport::Logging
+    include OrientDbPrivate
+    include DatabaseUtils
+    include ClassUtils
+    include RestRead
+    include RestCreate
+    include RestChange
+    include RestOperations
+    include RestDelete
+
+
+    #### INITIALIZATION ####
+
+=begin
+OrientDB is conventionally initialized.
+
+
+The first call initialises database-name and -classes, server-adress and user-credentials.
+
+Subsequent initialisations are made to initialise namespaced database classes, ie.
+
+	ORD =  ActiveOrient.init.connect  database: 'temp'
+																server:  'localhost',
+																port:    2480,
+																user:   root, 
+																password: root 
+	module HC; end
+	ActiveOrient::Init.define_namespace { HC }
+	ActiveOrient::OrientDB.new  preallocate: true 
+
+
+
+
+
+=end
+
+    def initialize database: nil, preallocate: true, model_dir: nil, **defaults
+      ActiveOrient.database ||= database || 'temp'
+      ActiveOrient.database_classes ||=   Hash.new
+
+			ActiveOrient.default_server ||= { :server => defaults[:server] || 'localhost' ,
+																				:port   => defaults[:port] ||= 2480,
+																				:user   => defaults[:user].to_s ,
+																				:password => defaults[:password].to_s }
+			# setup connection pool
+			# database-settings: client.channel.maxPool = 100
+			ActiveOrient.db_pool ||= Pond.new( :maximum_size => 25, :timeout => 50) {  get_resource }
+#			ActiveOrient.db_pool.collection = :stack
+      connect() 
+      database_classes # initialize @classes-array and ActiveOrient.database_classes 
+			ActiveOrient::Base.logger =  logger
+      ActiveOrient::Model.orientdb = self 
+      ActiveOrient::Model.db = self 
+      ActiveOrient::Model.keep_models_without_file ||= nil
+      preallocate_classes( model_dir )  if preallocate
+			Thread.abort_on_exception = true
+    end
+
+		# thread safe method to allocate a resource
+    def get_resource
+			logger.debug {"ALLOCATING NEW RESOURCE --> #{ ActiveOrient.db_pool.size }" }
+      login = [ActiveOrient.default_server[:user] , ActiveOrient.default_server[:password]]
+      server_adress = "http://#{ActiveOrient.default_server[:server]}:#{ActiveOrient.default_server[:port]}"
+			 RestClient::Resource.new(server_adress, *login)
+    end
+
+
+
+# Used to connect to the database
+
+		def connect 
+			first_tentative = true
+			begin
+				database =  ActiveOrient.database
+				logger.progname = 'OrientDB#Connect'
+				r = ActiveOrient.db_pool.checkout do | conn |
+					r = conn["/connect/#{database}"].get
+				end
+				if r.code == 204
+					logger.info{"Connected to database #{database}"}
+					true
+				else
+					logger.error{"Connection to database #{database} could NOT be established"}
+					nil
+				end
+			rescue RestClient::Unauthorized => e
+				if first_tentative
+					logger.info{"Database #{database} NOT present --> creating"}
+					first_tentative = false
+					create_database database: database
+					retry
+				else
+					Kernel.exit
+				end
+			end
+		end
+	end
+end

data/lib/rest_disabled.rb

@@ -0,0 +1,24 @@
+=begin #nodoc#
+If properties are allocated on class-level, they can be preinitialized using
+this method.
+This is disabled for now, because it does not seem nessesary
+=end
+
+def preallocate_class_properties o_class  # :nodoc:
+  p= get_class_properties( o_class )['properties']
+  unless p.nil? || p.blank?
+    predefined_attributes = p.map do | property |
+      [ property['name'] ,
+      case property['type']
+      when 'LINKMAP'
+        Array.new
+      when 'STRING'
+        ''
+      else
+        nil
+      end  ]
+    end.to_h
+  else
+    {}
+  end
+end

data/lib/support/conversions.rb

@@ -0,0 +1,42 @@
+=begin
+Rails-specific stuff
+
+Mimics ActiveModell::conversions
+=end
+module  Conversions
+
+
+=begin
+  Returns an Array of all key attributes if any is set, regardless if the object is persisted or not. Returns nil if there are no key attributes.
+=end
+   def to_key
+           key = respond_to?(:rid) && rid
+	         key ? [key] : nil
+   end
+
+ # Returns a +string+ representing the object's key suitable for use in URLs,
+ #     # or +nil+ if <tt>persisted?</tt> is +false+.
+  def to_param
+          (persisted? && key = to_key) ? key.join('-') : nil
+  end
+
+
+ # Returns a +string+ identifying the path associated with the object.
+ #     # ActionPack uses this to find a suitable partial to represent the object.
+ def to_partial_path
+         self.class._to_partial_path
+ end
+
+# module ClassMethods #:nodoc:
+   # Provide a class level cache for #to_partial_path. This is an
+   # internal method and should not be accessed directly.
+   
+#   def self._to_partial_path #:nodoc:
+#     @_to_partial_path ||= begin
+#	element = ActiveSupport::Inflector.underscore(ActiveSupport::Inflector.demodulize(name))
+#	collection = ActiveSupport::Inflector.tableize(name)
+#	"#{collection}/#{element}".freeze
+#      end
+#   end
+ #end
+end

data/lib/support/default_formatter.rb

@@ -0,0 +1,7 @@
+module OrientSupport
+    class DefaultFormatter < Logger::Formatter
+        def self.call(severity, time, program_name, msg)
+       "#{time.strftime("%d.%m.(%X)")}#{"%5s" % severity}->#{msg}"
+        end
+    end
+end

data/lib/support/errors.rb

@@ -0,0 +1,41 @@
+module ActiveOrient
+	module Error
+  # Error handling
+  class Error < RuntimeError
+  end
+
+  class ArgumentError < ArgumentError
+  end
+
+  class SymbolError < ArgumentError
+  end
+
+  class LoadError < LoadError
+  end
+
+  class ServerError < RuntimeError
+  end
+end # module IB
+end
+# Patching Object with universally accessible top level error method. 
+# The method is used throughout the lib instead of plainly raising exceptions. 
+# This allows lib user to easily inject user-specific error handling into the lib 
+# by just replacing Object#error method.
+def error message, type=:standard, backtrace=nil
+  e = case type
+  when :standard
+    ActiveOrientOrient::Error.new message
+  when :args
+    ActiveOrient::ArgumentError.new message
+  when :symbol
+    ActiveOrient::SymbolError.new message
+  when :load
+    AcitveOrient::LoadError.new message
+  when :server
+    ActiveOrient::Error::ServerError.new message
+  end
+  e.set_backtrace(backtrace) if backtrace
+  raise e
+end
+
+# resued from https://github.com/ib-ruby/ib-ruby

data/lib/support/logging.rb

@@ -0,0 +1,38 @@
+#require_relative 'default_formatter'
+module  OrientSupport
+	module Logging
+		def self.included(base)
+			base.extend ClassMethods
+			base.send :define_method, :logger do
+				base.logger
+			end
+		end
+
+		module ClassMethods
+			def logger
+				@logger
+			end
+
+			def logger=(logger)
+				@logger = logger
+			end
+
+			def configure_logger(log= nil)
+				if log
+					@logger = log
+				else
+					@logger = Logger.new(STDOUT)
+					@logger.level = Logger::INFO
+					@logger.formatter = DefaultFormatter
+				end
+			end
+		end
+	end
+
+	class DefaultFormatter < Logger::Formatter
+		def self.call(severity, time, program_name, msg)
+			"#{time.strftime("%d.%m.(%X)")}#{"%5s" % severity}->#{msg}\n"
+		end
+	end
+end
+# source: https://github.com/jondot/sneakers/blob/master/lib/sneakers/concerns/logging.rb

data/lib/support/orient.rb

@@ -0,0 +1,305 @@
+module OrientSupport
+
+	# This Module fences specialized Ruby objects
+
+	# The Array _knows_ its database-class. This enables database-transactions outside the scope
+	# of ActiveOrient
+	#
+	# The Database-Class is available through Array#record
+#
+# *caution:*
+# Don't mix ActiveOrient::Array's with conventional ones
+#   	> t= G21.first
+#     > t.ll
+#      => ["test", "test_2", 5, 8, 7988, "uzg"]
+#   	> t.ll = [9,6,7]    # This is an assignment of an Array to the variable »ll»
+#													# It does NOT call ActiveOrient::Array#=[]. 
+#   	 => [9, 6, 7]       # Instead an Array is assigned to the variable  »ll»
+#   
+# it is only updated localy, as shown if we reload the document
+#     > t= G21.first.attributes
+#      => {:ll=>["test", "test_2", 5, 8, 7988, "uzg"]} 
+#   
+# Thus its imperativ to safe the changes made.
+   
+   
+	class Array < Array
+		include OrientSupport::Support
+
+=begin
+	During initialisation  the model-instance to work on is stored  in @orient.
+
+	The keyword_parameter »work_on« holds the record to work on.
+	The second argument holds 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
+
+	Its used to initialize Objects comming from the database (i.e. /lib/base.rb)
+
+		 elsif iv.is_a? Array
+					 OrientSupport::Array.new( work_on: self, work_with: iv.from_orient){ key.to_sym }
+
+=end
+
+		def initialize( work_on:, work_with: )
+			@orient = work_on.class == Class ? work_on.new : work_on
+			super work_with
+			begin
+			@name =  block_given? ? yield : @orient.attributes.key(self)
+			rescue TypeError => e   #  not defined
+				ActiveOrient::Base.logger.debug{ "--------------------Type Error ----------------------------------" }
+			ActiveOrient::Base.logger.debug("OrientSupport::Array"){ "Attributes  #{@orient.attributes.inspect}" }
+			ActiveOrient::Base.logger.debug("OrientSupport::Array"){ e.inspect 
+			ActiveOrient::Base.logger.debug{ "indicates a try to access a non existing array element" }}
+			nil
+			rescue NameError =>e
+			ActiveOrient::Base.logger.debug{ "--------------------Name Error ------------" }
+			ActiveOrient::Base.logger.debug ("OrientSupport::Array"){ e.inspect }
+			#ActiveOrient::Base.logger.error{ e.backtrace.map {|l| "  #{l}\n"}.join  }
+			ActiveOrient::Base.logger.debug{ "due to a bug in ActiveSupport DateTime Calculations" }
+			# we just ignore the error
+			end
+		end
+		def as_json o=nil
+			map{|x| x.rid? ? x.rid : x }
+		end
+
+		def record
+			@orient
+		end
+
+		def to_human
+			map &:to_human 
+		end
+=begin
+
+Appends the arguments to the Array.
+
+Returns the modified database-document (not the array !!)
+=end
+		def   append *arg
+			
+			@orient.update { "set #{@name.to_s} = #{@name} || #{arg.to_or} "}[@name] if check_if_complete
+			@orient.reload!
+		end
+=begin
+Append the argument to the Array, changes the Array itself.
+
+Returns the modified Array ( and is chainable )
+#
+#      i= V.get( '89:0')
+	#    ii=i.zwoebelkuchen <<  'z78' << 6 << [454, 787]
+	#		 => [7, 5, 6, "z78", 78, 45, "z78", 6, 454, 787] 
+
+The change is immediately transmitted to the database. 
+
+The difference to `append`: that method accepts a komma separated list of arguments
+and returns the modified database-document. `<<` accepts only one argument. An 
+Array  is translated into multi-arguments of `append`
+
+	> t =  G21.create  ll:  ['test','test_2', 5, 8 , 7988, "uzg"]
+	  INFO->CREATE VERTEX ml_g21 CONTENT {"ll":["test","test_2",5,8,7988,"uzg"]}
+	  => #<ML::G21:0x0000000002622cb0 @metadata={:type=>"d", :class=>"ml_g21", :version=>1, 
+	  :fieldTypes=>nil, :cluster=>271, :record=>0}, 
+		@attributes={:ll=>["test", "test_2", 5, 8, 7988, "uzg"]}> 
+ > t.ll << [9,10]
+    INFO->update #271:0 set ll = ll || [9, 10]   return after @this
+     => ["test", "test_2", 5, 8, 7988, "uzg"] 
+ > t.ll << [9,10] << 'u'
+    INFO->update #271:0 set ll = ll || [9, 10]   return after @this
+    INFO->update #271:0 set ll = ll || ['u']   return after @this
+ => ["test", "test_2", 5, 8, 7988, "uzg", 9, 10]
+
+
+The Array can be treated separately
+
+  > z =  t.ll
+	 => ["test", "test_2", 5, 8, 7988, "uzg"] 
+  > z << 78
+  INFO->update #272:0 set ll = ll || [78]   return after @this
+  => ["test", "test_2", 5, 8, 7988, "uzg", 78] 
+
+=end
+		def << arg
+			append( *arg).send @name 
+		end
+
+=begin
+
+Removes the specified list entries from the Array
+
+Returns the modified Array  (and is chainable).
+
+ > t= G21.first
+ > t.ll
+   => ["test", "test_2", 7988, "uzg", 6789, "xvy"] 
+ > u=  t.ll << 'xvz'
+ # INFO->update #272:0 set ll = ll || ['xvz']   return after @this
+ => ["test", "test_2", 7988, "uzg", 6789, "xvy", "xvz"] 
+ > z=  u.remove 'xvy'
+ # INFO->update #272:0 remove  ll = 'xvy'  return after @this
+ => ["test", "test_2", 7988, "uzg", 6789, "xvz"] 
+
+The ModelInstance is updated, too, as shown by calling 
+
+> t.ll
+ => ["test", "test_2", 7988, "uzg", 6789, "xvz"] 
+
+
+Thus 
+
+ > t.ll.remove 7988
+ # INFO->update #272:0 remove  ll = 7988  return after @this
+ => ["test", "test_2", "uzg", 6789, "xvz"] 
+ 
+returns thea modified Array 
+=end
+		def remove *k
+			# todo combine queries in a transaction
+			ActiveOrient::Base.logger.debug { "delete: #{@name} --< #{k.map(&:to_or).join( ' :: ' )}"}
+		 k.map{|l|	@orient.update( {remove: { @name => l} } ) }
+	#		@orient.reload!
+	#		@orient.send @name 
+		end
+
+		def remove_by_index index
+			@orient.update( { remove: { @name => "#{@name[index]}" } } )
+		end
+
+def check_if_complete
+	if @name.blank?
+		@orient.logger.warn{ "Database is uneffected. Operation is incomplete/ not allowed" }
+		false
+	else
+		true
+	end
+end
+=begin
+	Updating of single items
+=end
+		def []= key, value
+			super
+			@orient.update set: {@name => self} if @name.present?  if check_if_complete
+		end
+
+
+		###
+		## just works with Hashes as parameters
+		def where *item
+			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
+			@orient.db.execute{  q.to_s } if check_if_complete
+
+		end
+
+		def method_missing method, *args
+			return if empty?
+			if @orient.is_a? ActiveOrient::Model  #  IB::Model
+				# delegate to public methods
+				self.map{|x| x.public_send(method, *args)}
+			else
+				self.map{|x| x.send method, *args }
+			end
+		rescue NoMethodError => e
+			ActiveOrient::Base.logger.error("OrientSupport::Array"){ "#{self.inspect} MethodMissing  -> Undefined method: #{args.first} --  Args: #{args[1..-1].inspect}"}
+			ActiveOrient::Base.logger.error {" The Message #{e.message}"}
+			ActiveOrient::Base.logger.error{ e.backtrace.map {|l| "  #{l}\n"}.join  }
+			raise
+		end
+
+	end #Class
+
+
+
+
+	class Hash  < Hash # WithIndifferentAccess
+		include OrientSupport::Support
+		def initialize modelinstance, args
+			super()
+			@orient = modelinstance
+			self.merge! args
+			@name =  block_given? ? yield : modelinstance.attributes.key(self)
+			self
+		end
+
+		def store  k, v
+			@orient.update { "set #{@name}[#{k.to_s.to_or}] = #{v.to_or} "}[@name] #if check_if_complete
+			@orient.reload!
+		end
+
+		alias []= store
+
+
+# Inserts the provided Hash to the (possibly empty) list-property and updates the dataset
+		#
+		# Keys are translated to symbols 
+		#
+		def merge **arg
+			@orient.update @name => super(**arg)
+			@orient.reload!
+		end
+
+		alias  << merge 
+
+# removes a key-value entry from the hash. 
+# 
+# parameter: list of key's 
+#
+# returns the modified OrientSupport::Hash 
+		#
+		# ie, given
+		#  b =>  <Base[51:0]: < Base: 51:0 >, a_set : {:warrant_value=>["8789", "HKD"], :what_if_pm_enabled=>["true", ""], :t_bill_value=>["0", "HKD"]}>
+		# c= b.a_set.remove :warrant_value
+		# INFO->update #51:0  remove a_set = 'warrant_value'   return after $current
+		# c =>  {:what_if_pm_enabled=>["true", ""], :t_bill_value=>["0", "HKD"]}
+
+
+		def remove *k
+			# todo combine queries in a transaction
+
+			r=  k.map{|key|	@orient.update{   "remove #{@name} = #{key.to_s.to_or} "  } }
+			@orient.reload!.send @name
+
+		end
+
+		def delete_if &b
+			super &b
+			@orient.update set:{ @name => self}
+
+		end
+
+ # slice returns a subset of the hash 
+		#
+		# excepts a regular expression as well
+		def slice arg
+			if arg.is_a? Regexp
+				find_all{ |key| key.to_s.match(arg) }.to_h
+			else
+				 super arg.to_sym
+			end
+		end
+		def [] arg
+			super
+		end
+	end
+end #Module
+
+class Hash
+
+	  def to_human
+			"{ " + self.map{ |k,v| [k.to_s,": ", v.to_orient].join }.join(', ') + " }"
+		end
+
+	#	def coerce arg
+	#		if arg.is_a? DateTime
+	#			nil
+	#		else
+	#			super
+#
+#			end
+#		end
+end