active-orient 0.42 → 0.79

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/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,196 @@
+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
+
+
+	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 = @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
+			@name =  yield if @name.nil? && block_given?
+		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
+#		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] 
+=begin
+Append the argument to the Array, changes the Array itself.
+
+The change is immediately transmitted to the database. 
+
+
+=end
+		def   append *arg
+
+			@orient.update { "#{@name.to_s} = #{@name} || #{arg.to_or} "}[@name]
+		end
+
+		alias  << append 
+
+		def remove *k
+			# todo combine queries in a transaction
+			puts "delete: #{@name} --< #{k.map(&:to_or).join( ' :: ' )}"
+			k.each{|item| @orient.remove( " #{@name} = #{item.to_or}")[@name] }
+		end
+
+
+
+=begin
+	Updating of single items
+=end
+
+		def []= key, value
+			super
+			@orient.update set: {@name => self} 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 ')
+			subquery= OrientSupport::OrientQuery.new from: @orient, projection: "expand( #{@name})"
+			q= OrientSupport::OrientQuery.new from: subquery, where: item
+			@orient.query q.to_s 
+
+		end
+
+		def method_missing *args
+
+			self.map{|x| x.send *args }
+		rescue NoMethodError => e
+			ActiveOrient::Base.logger.error("OrientSupport::Array"){ "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  }
+		end
+
+	end #Class
+
+
+
+
+	class Hash  < Hash # WithIndifferentAccess
+		include OrientSupport::Support
+		def initialize modelinstance, args
+			super()
+		#	puts "Hash.new args #{args}"
+			@orient = modelinstance
+			self.merge! args
+			@name = modelinstance.attributes.key(self)
+			@name =  yield if @name.nil? && block_given?
+		#	puts "@name #{@name}"
+			self
+		end
+
+
+		def []=  k, v
+			 @orient.update { "#{@name.to_s}.#{k.to_s} = #{v.to_or}" }
+		end
+
+# Inserts the provided Hash to the (possibly emty) list-property and returns a hash	
+		def append arg
+			# the argument is simply provided as JSON-parameter to »update«
+			# generated query: update {rrid} set { @name } = { arg.to_json } return after @this
+			# todo : consider returning a OrientSuport::Hash
+			@orient.update { "#{@name.to_s} = "+ arg.to_json }[@name]
+		end
+
+		alias  << append 
+
+# removes a key-value entry from the hash. 
+# 
+# parameter: list of key's (duplicate values are removed)
+		def remove *k
+			# todo combine queries in a transaction
+			k.map{ |key| @orient.update( remove: true ) { "#{@name.to_s}.#{key} " } }.last
+		end
+	#	def delete *key
+#
+#			key.each do | k |
+#				o = OrientSupport::OrientQuery.new from: @orient, 
+#																						kind: 'update', 
+#																						set: "#{@name}.#{k.to_s}",
+#																					return: "$current.#{@name}"
+#			@orient.db.execute{  o.to_s.gsub( 'set ', 'remove ' ) }.first.send( @name )  # extracts the modified array (from DB)  from the result
+#			end
+#			@orient.reload!
+#			@orient.send @name  # return value
+#	end
+
+		def delete_if &b
+			super &b
+			@orient.update set:{ @name => self}
+
+		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

data/lib/support/orientquery.rb

@@ -0,0 +1,469 @@
+require 'active_support/inflector'
+module OrientSupport
+  module Support
+
+=begin
+supports
+  where: 'string'
+  where: { property: 'value', property: value, ... }
+  where: ['string, { property: value, ... }, ... ]
+
+Used by update and select
+
+_Usecase:_
+ ORD.compose_where 'z=34', {u:6}
+  => "where z=34 and u = 6" 
+=end
+
+    #
+    def compose_where *arg , &b
+      arg = arg.flatten
+      return "" if arg.blank? || arg.size == 1 && arg.first.blank?
+      "where " + generate_sql_list( arg , &b)
+    end
+
+=begin
+designs a list of "Key =  Value" pairs combined by "and" or the binding  provided by the block
+   ORD.generate_sql_list  where: 25 , upper: '65' 
+    => "where = 25 and upper = '65'"
+   ORD.generate_sql_list(  con_id: 25 , symbol: :G) { ',' } 
+    => "con_id = 25 , symbol = 'G'"
+=end
+		def generate_sql_list attributes = {}, &b
+			fill = block_given? ? yield : 'and'
+			a=	case attributes 
+					when ::Hash
+						attributes.map do |key, value|
+							case value
+							when ActiveOrient::Model
+								"#{key} = #{value.rrid}"
+							when Numeric
+								"#{key} = #{value}"
+							when ::Array
+								"#{key} in [#{value.to_orient}]"
+							when Range
+								"#{key} between #{value.first} and #{value.last} " 
+							when DateTime
+								"#{key} = date(\'#{value.strftime("%Y%m%d%H%M%S")}\',\'yyyyMMddHHmmss\')"
+							when Date
+								"#{key} = date(\'#{value.to_s}\',\'yyyy-MM-dd\')"
+							else #  String, Symbol, Time, Trueclass, Falseclass ...
+								"#{key} = \'#{value.to_s}\'"
+							end
+						end.join(" #{fill} ")
+					when ::Array
+						attributes.map{|y| generate_sql_list y, &b }.join( " #{fill} " )
+					when String
+						attributes
+					end		
+		end
+  end
+
+
+  class MatchConnection
+    attr_accessor :as
+    def initialize edge: nil, direction: :both, as: nil, count: 1
+      @edge = edge
+      @direction = direction  # may be :both, :in, :out
+      @as =  as
+      @count =  count
+    end
+
+    def direction= dir
+      @direction =  dir
+    end
+
+
+    def direction
+      fillup =  @edge.present? ? @edge : ''
+      case @direction
+      when :both
+	" -#{fillup}- "
+      when :in
+	" <-#{fillup}- "
+      when :out
+	" -#{fillup}-> "
+      end
+
+    end
+
+    def compose
+      ministatement = @as.present? ? "{ as: #{@as} } " : "" 
+     (1 .. @count).map{|x| direction }.join("{}") << ministatement
+
+    end
+    
+  end
+
+  class MatchStatement
+    include Support
+    attr_accessor :as
+    attr_accessor :where
+    def initialize match_class=nil, **args
+      @misc  = []
+      @where = []
+      @while = []
+      @maxdepth = 0
+      @as =  nil
+
+
+      @match_class = match_class
+      @as = match_class.pluralize if match_class.is_a? String
+
+      args.each do |k, v|
+        case k
+	when :as
+	  @as = v
+        when :while
+          @while << v
+        when :where
+          @where << v
+	when :class
+	  @match_class = v
+	  @as = v.pluralize
+        else
+          self.send k, v
+        end
+      end
+    end
+    
+        def while_s
+  	  compose_where( @while ).gsub( /where/, 'while:(' )<< ")" unless @while.blank?
+    end
+
+    def match_alias
+      "as: #{@as }"
+    end
+    def where_s
+  	  compose_where( @where ).gsub( /where/, 'where:(' )<< ")"  unless @where.blank?
+    end
+  
+    def maxdepth=x
+      @maxdepth = x
+    end
+
+    def method_missing method, *arg, &b
+      @misc << method.to_s <<  generate_sql_list(arg) 
+    end
+
+    def misc
+      @misc.join(' ') unless @misc.empty?
+    end
+    # used for the first compose-statement of a compose-query
+    def compose_simple
+   '{'+ [ "class: #{@match_class}", 
+	       "as: #{@as}" , 
+	       where_s ].compact.join(', ') + '}'
+    end
+
+    def compose
+
+        '{'+ [ "class: #{@match_class}", 
+	       "as: #{@as}" , 
+	       where_s, 
+	      while_s, 
+	      @maxdepth >0 ? "maxdepth: #{maxdepth}": nil  ].compact.join(', ')+'}'
+    end
+    alias :to_s :compose
+end
+
+  class OrientQuery
+    include Support
+
+
+    attr_accessor :where
+    attr_accessor :let
+    attr_accessor :projection
+    attr_accessor :order
+    attr_accessor :db
+    attr_accessor :match_statements
+
+    def initialize  **args
+      @projection = []
+      @misc  = []
+      @let   = []
+      @where = []
+      @order = []
+      @aliases = []
+      @match_statements = []
+      @class =  nil
+			@return = nil
+			@db = nil
+      @kind  = 'select'
+      args.each do |k, v|
+        case k
+				when :projection
+					@projection << v
+				when :let
+					@let << v
+				when :order
+					@order << v
+				when :where
+					@where << v
+				when :kind
+					@kind = v
+				when :start
+					@match_statements[0] = MatchStatement.new **v
+					#  @match_statements[1] = MatchConnection.new
+				when :connection
+					@match_statements[1] = MatchConnection.new **v
+				when :return
+					@aliases << v
+				else
+					self.send k, v
+				end
+			end
+		end
+
+
+=begin
+  where: "r > 9"                          --> where r > 9
+  where: {a: 9, b: 's'}                   --> where a = 9 and b = 's'
+  where:[{ a: 2} , 'b > 3',{ c: 'ufz' }]  --> where a = 2 and b > 3 and c = 'ufz'
+=end
+		def method_missing method, *arg, &b   # :nodoc: 
+      @misc << method.to_s <<  generate_sql_list(arg) 
+			self.to_s  # return compiled result
+    end
+
+
+    def misc   # :nodoc:
+      @misc.join(' ') unless @misc.empty?
+	#		self.to_s  # return compiled result
+    end
+
+    def subquery  # :nodoc: 
+      nil
+    end
+
+
+
+=begin
+(only if kind == :match): connect
+
+Add a connection to the match-query
+
+A Match-Query alwas has an Entry-Stratement and maybe other Statements.
+They are connected via " -> " (outE), "<-" (inE) or "--" (both).
+
+The connection method adds a connection to the statement-stack. 
+
+Parameters:
+  direction: :in, :out, :both
+  edge_class: to restrict the Query on a certain Edge-Class
+  count: To repeat the connection
+  as:  Includes a micro-statement to finalize the Match-Query
+       as: defines a output-variablet, which is used later in the return-statement
+
+The method returns the OrientSupport::MatchConnection object, which can be modified further.
+It is compiled by calling compose
+=end
+
+		def connect direction, edge_class: nil, count: 1, as: nil
+			direction= :both unless [ :in, :out].include? direction
+			match_statements << m = OrientSupport::MatchConnection.new( direction: direction, count: count, as: as)
+			m
+		end
+
+=begin
+(only if kind == :match): statement
+
+A Match Query consists of a simple start-statement
+( classname and where-condition ), a connection followd by other Statement-connection-pairs.
+It performs a sub-query starting at the given entry-point.
+
+Statement adds a statement to the statement-stack.
+Statement returns the created OrientSupport::MatchStatement-record for further modifications. 
+It is compiled by calling »compose«. 
+
+OrientSupport::OrientQuery collects any "as"-directive for inclusion  in the return-statement
+
+Parameter (all optional)
+ Class: classname, :where: {}, while: {}, as: string, maxdepth: >0 , 
+
+=end
+	def statement match_class= nil, **args
+		match_statements << s = OrientSupport::MatchStatement.new( mattch_class, args )
+		s
+	end
+=begin
+  Output the compiled query
+  Parameter: destination (rest, batch )
+  If the query is submitted via the REST-Interface (as get-command), the limit parameter is extracted.
+=end
+
+	def compose(destination: :batch)
+		if @kind == :match
+			unless @match_statements.empty?
+				match_query =  @kind.to_s.upcase + " "+ @match_statements[0].compose_simple 
+				match_query << @match_statements[1..-1].map( &:compose ).join
+				match_query << " RETURN "<< (@match_statements.map( &:as ).compact | @aliases).join(', ')
+			end
+		elsif @kind.to_sym == :update
+			return_statement = "return after " + ( @aliases.empty? ?  "$this" : @aliases.first.to_s)
+			[ @kind, @database, misc, where_s, return_statement ].compact.join(' ')
+		elsif destination == :rest
+			[@kind, projection_s, from, let_s, where_s, subquery, misc, order_s, group_by, unwind, skip].compact.join(' ')
+		else
+			[@kind, projection_s, from, let_s, where_s, subquery, misc, order_s, group_by, limit, unwind, skip].compact.join(' ')
+		end
+	end
+	alias :to_s :compose
+
+=begin
+  from can either be a Databaseclass to operate on or a Subquery providing data to query further
+=end
+
+
+	def from arg = nil
+		if arg.present?
+			@database = case arg
+									when ActiveOrient::Model   # a single record
+										arg.rrid
+									when OrientQuery	      # result of a query
+										' ( '+ arg.to_s + ' ) '
+									when Class
+										arg.ref_name
+									else
+										if arg.to_s.rid?	  # a string with "#ab:cd"
+											arg
+										else		  # a database-class-name
+											arg.to_s  
+										end
+									end
+			compose  # return the complete query
+		else # read from
+			"from #{@database}" unless @database.nil?
+		end
+	end
+	alias :from= :from
+
+    def database_class            # :nodoc:
+  	  if @database.present?
+  	    @database
+  	  elsif @from.is_a? OrientQuery
+  	    @from.database_class
+  	  else
+  	    nil
+  	  end
+    end
+
+    def database_class= arg   # :nodoc:
+  	  @database = arg if @database.present?
+  	  if @from.is_a? OrientQuery
+  	    @from.database_class= arg
+  	  end
+    end
+
+    def where_s        # :nodoc:
+  	  compose_where @where
+    end
+
+    def let_s           # :nodoc:
+  	  unless @let.empty?
+  	    "let " << @let.map do |s|
+  	      case s
+  	      when String
+  	        s
+  	      when Array
+  	        s.join(',  ')
+#	      when Hash  ### is not recognized in jruby
+	      else
+  	        s.map{|x,y| "$#{x} = (#{y})"}.join(', ')
+  	      end
+  	    end.join(', ')
+  	  end
+    end
+
+    def distinct d
+			@projection <<  case d
+			when String, Symbol
+				"distinct #{d.to_s} "
+			else
+				dd= d.to_a.flatten
+				"distinct  #{dd.first.to_s}  as #{dd.last}"
+			end
+			compose
+    end
+    alias :distinct= :distinct
+
+    def projection_s   # :nodoc:
+  	  @projection.map do | s |
+  		  case s
+  			when Array
+  			  s.join(', ')
+			when String, Symbol
+  			  s.to_s
+  			else
+  			  s.map{ |x,y| "#{x} as #{y}"}.join( ', ')
+  			end
+  	  end.join( ', ' )
+    end
+
+    def limit l=nil
+  	  @limit = "limit #{l.to_s}" if l.present?
+  	# only a string is allowed
+  	  @limit
+    end
+    alias :limit= :limit
+
+    def get_limit  # :nodoc: 
+    	@limit.nil? ? -1 : @limit.split(' ').last.to_i
+    end
+
+		def expand item
+			@projection =[ " expand ( #{item.to_s} )" ]
+			compose
+    end
+
+
+		def nodes in_or_out = :out, via:  nil, where: nil, expand: true
+			 condition = where.present? ?  "[ #{generate_sql_list(where)} ]" : ""
+			 start =  in_or_out 
+			 the_end =  in_or_out == :in ? :out : :in
+			 argument = " #{start}E(#{via.to_or if via.present?}).#{the_end}#{condition} "
+
+			 if expand.present?
+				 send :expand, argument
+			 else
+			 @projection  << argument 
+			 end
+			 compose
+		end
+
+    def group_by g = nil
+     	@group = "group by #{g.to_s}" if g.present?
+  	# only a string is allowed
+  	   @group
+    end
+
+    def unwind u = nil
+  	  @unwind = "unwind #{u.to_s}" if u.present?
+  	# only a string is allowed
+  	  @unwind
+    end
+
+    def skip n = nil
+  	  @skip = n if n.present?
+  	  "skip #{@skip}" if @skip.present?
+    end
+
+    def order_s    # :nodoc:
+      unless @order.empty?
+	# the [@order] is nessesary to enable query.order= "..." oder query.order= { a: :b }
+	"order by " << [@order].flatten.map do |o|
+	  case o
+	  when String, Symbol, Array
+	    o.to_s
+	  else
+	    o.map{|x,y| "#{x} #{y}"}.join(" ")
+	  end  # case
+	end.join(', ')
+      else
+	''
+      end # unless
+    end	  # def
+    end # class
+
+
+end # module