orientdb-time-graph 0.7

data/model/tg/tag.rb

@@ -0,0 +1,63 @@
+#ActiveOrient::Model.orientdb_class name: 'time_base', superclass: 'V'
+class  TG::Tag # < TG::TimeBase
+	def _monat
+		query.nodes :in, via: TG::DAY_OF
+	end
+
+	def die_stunde h
+		h.to_i >0 && h.to_i<31 ? out_tg_time_of[h].in : nil
+	end
+
+	def stunde *key
+		if key.empty?
+			out_tg_time_of.in
+		else
+			key=  key.first		if key.is_a?(Array) && key.size == 1 
+			nodes( :out, via: TG::TIME_OF, where: { value: key } ).execute
+		end
+	end
+
+
+  def monat
+		_monat.execute.first
+#    in_tg_day_of.out.first
+  end
+
+  def datum
+		# three queries are fired
+		# todo
+		# formulate a match query providing anythin in just one query
+    m = monat
+     Date.new m.jahr.value, m.value, value #   "#{ value}.#{m.value}.#{m.jahr.value}"
+  end
+
+=begin
+ Fetches the vertex corresponding to the given date
+
+ (optional:  executes the provided block on the vertex )
+
+ Example:
+
+	start_date=  Date.new(2018,4,25)
+	TG::Tag.fetch( start_date){ |x| x.datum }  
+	=> ["25.4.2018"] 
+  TG::Tag.fetch( start_date){ |x| x.data_nodes( ML::L_OHLC).map &:to_human }
+  INFO->select  expand (  outE('tg_day_of').in[ value = 25 ]  ) from 
+	 	  ( select  expand (  outE('tg_month_of').in[ value = 4 ]  ) from  
+			( select  from tg_jahr where value = 2018  )    )   
+  INFO->select  expand (  outE('ml_l_ohlc').in  ) from #82:8927  
+  => ["<Ohlc[161:22]: in: {ML::L_OHLC=>1}, 
+	    close : 3485.83, high : 3500.6, low : 3464.35, open : 3500.6, time : 2018-04-25 00:00:00, 
+			trades : 1831, volume : 0, wap : 0.0>"] 
+=end
+	def self.fetch datum , &b  # parameter: a date
+#		query_database( "select  expand (out_tg_day_of.in[value = #{datum.day}]) from (select  expand (out_tg_month_of.in[value = #{datum.month}]) from (select from tg_jahr where value = #{datum.year} ) ) ") &.first
+		q = OrientSupport::OrientQuery.new  from: TG::Jahr, where: { value: datum.year }
+		w = OrientSupport::OrientQuery.new  from: q
+		w.nodes :out, via: TG::MONTH_OF, where: { value: datum.month }
+		x = OrientSupport::OrientQuery.new  from: w 
+		x.nodes :out, via: TG::DAY_OF, where: { value: datum.day }
+		x.execute.first
+	end
+
+end

data/model/tg/time_base.rb

@@ -0,0 +1,101 @@
+class  TG::TimeBase # < V
+
+=begin
+Searches for specific value records 
+
+Examples
+  Monat[8]  --> Array of all August-month-records
+  Jahr[1930 .. 1945]
+=end
+  def self.[] *key
+#    result = OrientSupport::Array.new( work_on: self, 
+#						work_with: db.execute{ "select from #{ref_name} #{db.compose_where( value: key.analyse)}" } )
+		key=  key.first		if key.is_a?(Array) && key.size == 1 
+		q= query.where( value: key).execute(reduce: true)
+#		result= query_database q
+#		result.size == 1 ? result.first : result # return object if only one record is fetched
+  end
+
+=begin
+Moves horizontally within the grid
+i.e
+  the_day =  "4.8.2000".to_tg
+  the_day.move(9).datum  # => "13.8.2000" 
+  the_day.move(-9).datum # => "26.7.2000"
+=end
+  def move count
+    dir =  count <0 ? 'in' : 'out' 
+    r= db.execute {  "select from ( traverse #{dir}(\"tg_grid_of\") from #{rrid} while $depth <= #{count.abs}) where $depth = #{count.abs} " }  
+    if r.size == 1
+      r.first
+    else
+      nil
+    end
+  end
+
+
+  def analyse_key key    # :nodoc:
+
+    new_key=  if key.first.is_a?(Range) 
+			   key.first
+			elsif key.size ==1
+			 key.first
+			else
+			  key
+			end
+  end
+=begin
+Get the nearest horizontal neighbours
+
+Takes one or two parameters. 
+
+  (TG::TimeBase.instance).environment: count_of_previous_nodes, count_of_future_nodes
+
+Default: return the previous and next 10 items
+
+   "22.4.1967".to_tg.environment.datum
+    => ["12.4.1967", "13.4.1967", "14.4.1967", "15.4.1967", "16.4.1967", "17.4.1967", "18.4.1967", "19.4.1967", "20.4.1967", "21.4.1967", "22.4.1967", "23.4.1967", "24.4.1967", "25.4.1967", "26.4.1967", "27.4.1967", "28.4.1967", "29.4.1967", "30.4.1967", "1.5.1967", "2.5.1967"]
+
+It returns an  OrientSupport::Array of TG::TimeBase-Objects
+
+
+
+=end
+
+#  def environment previous_items = 10, next_items = nil
+#    next_items =  previous_items  if next_items.nil?  # default : symmetric fetching
+#
+#    my_query =  -> (count) do
+#			dir =  count <0 ? 'in' : 'out'   
+#			db.execute {  "select from ( traverse #{dir}(\"tg_grid_of\") from #{rrid} while $depth <= #{count.abs}) where $depth >=1 " }   # don't fetch self and return an Array
+#		end
+#   prev_result = previous_items.zero? ?  []  :  my_query[ -previous_items.abs ] 
+#   next_result = next_items.zero? ?  []  : my_query[ next_items.abs ] 
+#   # return a collection suitable for further operations
+#   OrientSupport::Array.new work_on: self, work_with: (prev_result.reverse <<  self  | next_result )
+#
+#  end
+#
+
+  def environment previous_items = 10, next_items = nil
+    _environment(prevopus_items, next_items).execute
+	end
+
+  def _environment previous_items, next_items = nil
+		q = ->(**p){  OrientSupport::OrientQuery.new **p }
+     
+    next_items =  previous_items  if next_items.nil?  # default : symmetric fetching
+		local_var = :a
+		statement = q[]
+		{ in: previous_items , out: next_items}.each do | dir, items|
+				traverse_query = query kind: 'traverse', while: "$depth <= #{items}" 
+				traverse_query.nodes dir, via: TG::GRID_OF, expand: false
+				
+				statement.let  local_var =>  q[ from: traverse_query, where: '$depth >=1' ] 
+				local_var =  local_var.succ
+		end
+    statement.let  '$c= UNIONALL($a,$b) '
+    statement.expand( '$c')  # returns the statement
+	end
+
+end

data/model/tg/time_of.rb

@@ -0,0 +1,4 @@
+#ActiveOrient::Model.orientdb_class name: 'time_base', superclass: 'V'
+class  TG::TIME_OF # < E
+
+end

data/model/v.rb

@@ -0,0 +1,123 @@
+class V
+
+	# If the time_graph is used any Vertex class inherents the methods defined below. 
+	#
+	# Thus
+	#
+	#  if the vertices are connected via "...grid.." edges, they can be accessed by
+	#  * next
+	#  * prev
+	#  * move( count  )
+	#  * + (count)
+	#  * - (count)
+	#
+  def next
+		nodes( :out, via: /grid/ , expand: true).first
+  end
+  def prev
+		nodes( :in, via: /grid/ , expand: true).first
+  end
+
+		# simplified and specialized form of traverse
+		#
+		# we follow the graph (Direction: out) 
+		#
+		#    start = "1.1.2000".to_tg.nodes( via: /temp/ ).first 
+    #    or
+  	#    start = the_asset.at("1.1.2000")
+  	#    
+		#    start.vector(10) 
+	  #
+		#    start.vector(10, function: :median){"mean" } 
+		#
+		# with 
+		#  function: one of 'eval, min, max, sum abs, decimal, avg, count,mode, median, percentil, variance, stddev'
+		# and a block, specifying the  property to work with
+		#
+		def vector  length, where: nil, function: nil,  start_at: 0
+		  dir =  length <0 ? :in : :out ;
+			the_vector_query = traverse dir, via: /grid/, depth: length.abs, where: where, execute: false 
+#			the_vector_query.while "inE('ml_has_ohlc').out != #{to_tg.rrid}  " if to_tg.present?  future use
+			t=  OrientSupport::OrientQuery.new from: the_vector_query
+			t.where "$depth >= #{start_at}"	
+			if block_given?
+				if function.present? 
+					t.projection( "#{function}(#{yield})")
+					t.execute{ |result| result.to_a.flatten.last}.first
+				else
+					t.projection yield
+					t.execute{ |result| result.to_a.flatten.last}.compact
+				end
+			else
+				t.execute
+			end
+		end
+
+
+
+
+
+=begin
+Moves horizontally within the grid
+i.e
+  the_day =  "4.8.2000".to_tg
+  the_day.move(9).datum  # => "13.8.2000" 
+  the_day.move(-9).datum # => "26.7.2000"
+=end
+  def move count
+    dir =  count <0 ? :in : :out 
+		edge_class = detect_edges( dir, /grid/, expand: false )
+		q1 =  OrientSupport::OrientQuery.new( kind: :traverse )
+		  .while( " $depth <= #{count.abs}")
+			.from( self )
+			.nodes( dir, via: edge_class, expand: false)
+		
+		q2= OrientSupport::OrientQuery.new from: q1, where: "$depth = #{count.abs} "
+		r =  query q2
+
+
+#    r= db.execute {  "select from ( traverse #{dir}(\"tg_grid_of\") from #{rrid} while $depth <= #{count.abs}) where $depth = #{count.abs} " }  
+    if r.size == 1
+      r.first
+    else
+      nil
+    end
+  end
+=begin
+Get the node (item) grids in the future
+
+i.e.
+  the_month =  TG::Jahr[2000].monat(8).pop
+  the_month.value  # -> 8
+  future_month = the_month + 6
+  future_month.value # -> 2
+=end
+  def move_ item
+    move item
+  end
+	alias :+ :move_
+=begin
+Get the node (item) grids in the past
+
+i.e.
+  the_day =  "4.8.2000".to_tg
+  past_day = the_day - 6
+  past_day.datum #  => "29.7.2000"
+=end
+  def move__ item
+    move -item
+  end
+    
+	alias :- :move__
+
+# it is assumed, that any connection to the time-graph is done with an
+# edge-class containing "has", ie: has_temperature, has_ohlc, has_an_appointment_with 
+	def datum
+		nodes( :in, via: /has/ ).first.datum
+	end
+
+
+	def to_tg
+		nodes( :in, via: /has/ ).first
+	end
+end

data/orientdb_time_graph.gemspec

@@ -0,0 +1,25 @@
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+Gem::Specification.new do |s|
+  s.name        = "orientdb-time-graph"
+  s.version	= File.open('VERSION').read.strip
+  s.authors     = ["Hartmut Bischoff"]
+  s.email       = ["topofocus@gmail.com"]
+  s.homepage    = 'https://github.com/topofocus/orientdb_time_graph'
+  s.licenses    = ['MIT']
+  s.summary     = 'Implementation of a time graph in active.orient'
+  s.description = '' 
+  s.platform	= Gem::Platform::RUBY
+  s.required_ruby_version = '>= 2.6'
+  s.date 	= Time.now.strftime "%Y-%m-%d"
+  s.test_files  = `git ls-files -- {spec,features}/*`.split("\n")
+  s.require_paths = ["lib"]
+  s.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  s.bindir        = "exe"
+  s.executables   = s.files.grep(%r{^exe/}) { |f| File.basename(f) }
+   
+  s.add_development_dependency "bundler"
+  s.add_dependency 'active-orient'
+
+end

metadata

@@ -0,0 +1,98 @@
+--- !ruby/object:Gem::Specification
+name: orientdb-time-graph
+version: !ruby/object:Gem::Version
+  version: '0.7'
+platform: ruby
+authors:
+- Hartmut Bischoff
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2020-12-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: active-orient
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: ''
+email:
+- topofocus@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- Guardfile
+- LICENSE
+- README.md
+- VERSION
+- bin/console
+- config/boot.rb
+- config/config.yml
+- config/connect.yml
+- lib/init_db.rb
+- lib/orientdb_time_graph.rb
+- lib/setup.rb
+- lib/support.rb
+- lib/time_graph.rb
+- model/e.rb
+- model/tg/day_of.rb
+- model/tg/grid_of.rb
+- model/tg/jahr.rb
+- model/tg/monat.rb
+- model/tg/month_of.rb
+- model/tg/stunde.rb
+- model/tg/tag.rb
+- model/tg/time_base.rb
+- model/tg/time_of.rb
+- model/v.rb
+- orientdb_time_graph.gemspec
+homepage: https://github.com/topofocus/orientdb_time_graph
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.6'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.4
+signing_key: 
+specification_version: 4
+summary: Implementation of a time graph in active.orient
+test_files: []