active-orient 0.4 → 0.5

data/lib/orientdb_private.rb

@@ -0,0 +1,48 @@
+module OrientDbPrivate
+	private
+
+	def translate_property_hash field, type: nil, linked_class: nil, **args
+		type =  type.presence || args[:propertyType].presence || args[:property_type]
+		linked_class = linked_class.presence || args[:linkedClass] || args[:other_class]
+		if type.present?
+		  if linked_class.nil?
+		    {field => {propertyType: type.to_s.upcase}}
+		  else
+		    {field => {propertyType: type.to_s.upcase, linkedClass: classname(linked_class)}}
+		  end
+		end
+	end
+
+	# def property_uri this_classname
+	#   if block_given?
+	#     "property/#{@database}/#{this_classname}/" << yield
+	#   else
+	#     "property/#{@database}/#{this_classname}"
+	#   end
+	# end
+	#
+	# def self.simple_uri *names
+	#   names.each do |name|
+	#     m_name = ("#{name.to_s}_uri").to_sym
+	#     define_method(m_name) do |&b|
+	#       if b
+	#         "#{name.to_s}/#{@database}/#{b.call}"
+	#       else
+	#         "#{name.to_s}/#{@database}"
+	#       end # branch
+	#     end
+	#   end
+	# end
+	#
+	# def self.sql_uri *names
+	#   names.each do |name|
+	#     define_method(("#{name.to_s}_sql_uri").to_sym) do
+	#       "#{name.to_s}/#{@database}/sql/"
+	#     end
+	#   end
+	# end
+	#
+	# simple_uri :database, :document, :class, :batch, :function
+	# sql_uri :command, :query
+
+end

data/lib/other.rb

@@ -0,0 +1,280 @@
+# Class create to manage to_orient and from_orient
+
+class Array
+  def to_orient
+    map &:to_orient
+  end
+
+  def from_orient
+    map &:from_orient
+  end
+
+  def method_missing(method)
+    unless method == :to_hash || method == :to_str
+      return self.map{|x| x.public_send(method)}
+    end
+  end
+end
+
+#class RecordList
+#  def from_orient
+#      map &:from_orient
+#  end
+#end
+if RUBY_PLATFORM == 'java'
+  class Java::ComOrientechnologiesOrientCoreDbRecordRidbag::ORidBag
+    def from_orient
+      to_a.from_orient
+    end
+  end
+  
+  class Java::ComOrientechnologiesOrientCoreDbRecord::OTrackedList
+ #  class  RecordList
+    #   Basisklasse
+    #   Java::ComOrientechnologiesOrientCoreDbRecord::ORecordLazyList
+    #	Methode get(Index):  gibt das Dokument (Java::ComOrientechnologiesOrientCoreRecordImpl::ODocument) zurück
+    ## base = ActiveOrient::Model::Base.first
+    ## base.document.first_list
+    # => #<OrientDB::RecordList:[#21:0, #22:0, #23:0, #24:0, #21:1, #22:1, #23:1, #24:1, #21:2, #22:2]> 
+    ## base.first_list.get(3)
+    # => <OrientDB::Document:first_list:#24:0 second_list:#<OrientDB::RecordList:[#27:17, #28:17, #25:18, #26:18, #27:18, #28:18, #25:19, #26:19, #27:19, #28:19]> label:3> 
+    ## base.first_list[3]
+    #  => #<ActiveOrient::Model::FirstList:0x18df26a1  (...)
+    ## base.first_list[3].second_list[5]
+    #   => #<ActiveOrient::Model::SecondList: (...)
+    ##  base.first_list.get(3).second_list.get(5)
+    #    => <OrientDB::Document:second_list:#28:18 label:5> 
+    #
+    def from_orient
+      map &:from_orient
+      self
+    end
+    def to_orient
+      self
+    end
+
+    #def add value
+    #  puts "ASDSD"
+    #end
+    #
+    def to_a
+      super.map &:from_orient
+    end
+    def first
+      super.from_orient
+    end
+    def last
+      super.from_orient
+    end
+    def [] val
+	super.from_orient
+
+    end
+
+    def << value
+      #put "I will perform the insert"
+      value =  value.document if value.is_a?( ActiveOrient::Model ) && value.document.present?
+      add value
+      #save
+
+    end
+  end
+
+  class Java::ComOrientechnologiesOrientCoreDbRecord::OTrackedMap
+    def from_orient
+
+ #     puts self.inspect
+  #    puts self.keys.inspect
+     HashWithIndifferentAccess.new(self)
+    #  Kernel.exit
+#      map &:from_orient
+     # to_a.from_orient
+    end
+
+  end
+  class Java::JavaUtil::Date
+    def from_orient
+      Date.new(year+1900, month+1, date )
+    end
+    def to_orient
+      self
+    end
+  end
+
+
+end
+
+class Symbol
+  def from_orient
+    self
+  end
+end
+class FalseClass
+  def from_orient
+    self
+  end
+
+  def to_orient
+    self
+  end
+end
+
+class Hash #WithIndifferentAccess
+  def from_orient
+    substitute_hash = HashWithIndifferentAccess.new
+    #keys.each{|k| puts self[k].inspect}
+    keys.each{|k| substitute_hash[k] = self[k].from_orient}
+    substitute_hash
+  end
+
+  def to_orient
+    #puts "here hash"
+    substitute_hash = Hash.new
+    keys.each{|k| substitute_hash[k] = self[k].to_orient}
+    substitute_hash
+  end
+
+  def nested_under_indifferent_access
+    HashWithIndifferentAccess.new self
+  end
+end
+
+class Date
+  def to_orient
+    if RUBY_PLATFORM == 'java'
+      java.util.Date.new( year-1900, month-1, day , 0, 0 , 0 )  ## Jahr 0 => 1900
+    else
+      self
+    end
+  end
+  def from_orient
+    self
+  end
+end
+##module OrientDB
+#class Document
+#  def from_orient
+#    ActiveOrient::Model.autoload_object rid
+#  end
+#end
+#end
+class NilClass
+  def to_orient
+    self
+  end
+  def from_orient
+    nil
+  end
+end
+
+class Numeric
+  def from_orient
+    self
+  end
+
+  def to_orient
+    self
+  end
+
+  def to_or
+   "#{self.to_s}"
+  end
+end
+
+class String
+  def capitalize_first_letter
+    self.sub(/^(.)/) { $1.capitalize }
+  end
+
+  def from_orient
+	  if rid?
+	    ActiveOrient::Model.autoload_object self
+	  elsif
+	    self =~ /^:.*:$/
+	    self[1..-2].to_sym
+	  else
+	    self
+	  end
+  end
+#  alias :reload! from_orient
+# String#ToOrient: if the string contains "#xx:yy" omit quotes
+  def to_orient
+    if rid? 
+      if self[0] == "#"
+	self
+      else
+	"#"+self
+      end
+    else
+       self   # return the sting (not the quoted string. this is to_or)
+    end
+    #self.gsub /%/, '(percent)'
+   # quote 
+  end
+
+  # a rid is either #nn:nn and nn:nn
+  def rid?
+    self =~ /\A[#]{,1}[0-9]{1,}:[0-9]{1,}\z/
+  end
+
+#  return a valid rid or nil
+  def rid
+    rid? ? self : nil
+  end
+
+  def to_classname
+    if self[0] == '$'
+      self[1..-1]
+    else
+      self
+    end
+  end
+
+  def to_or
+   quote
+  end
+
+
+    def quote
+      str = self.dup
+      if str[0, 1] == "'" && str[-1, 1] == "'"
+	self
+      else
+	last_pos = 0
+	while (pos = str.index("'", last_pos))
+	  str.insert(pos, "\\") if pos > 0 && str[pos - 1, 1] != "\\"
+	  last_pos = pos + 1
+	end
+	"'#{str}'"
+      end
+    end
+
+
+end
+
+class Symbol
+  def to_orient
+    ":"+self.to_s+":"
+  end
+ ## there is no "from_orient" as symbols are stored as strings
+end
+
+class Time
+  def from_orient
+    self
+  end
+
+  def to_orient
+    self
+  end
+end
+
+class TrueClass
+  def from_orient
+    self
+  end
+
+  def to_orient
+    self
+  end
+end

data/lib/query.rb

@@ -1,88 +1,86 @@
+module ActiveOrient # :nodoc: 
 
-module ActiveOrient 
-class Query < ActiveOrient::Model
+## this is depreciated and not maintained anymore
+  class Query < ActiveOrient::Model
 
-   has_many :records
-   has_many :queries
+    has_many :records
+    has_many :queries
 
-   def reset_records
-     self.records= []
-   end
-   alias reset_results reset_records
+    def reset_records
+      self.records= []
+    end
+    alias reset_results reset_records
+
+    def reset_queries
+      self.queries = []
+    end
 
-   def reset_queries
-     self.queries = []
-   end
 =begin
-calls ActiveOrient::ActiveOrient#GetDocuments
-stores the query in the query-stack and saves the result in the record-Array
+  Calls ActiveOrient::ActiveOrient#GetRecords
+  Stores the query in the query-stack and saves the result in the record-Array
 
-returns the count of assigned records
+  Returns the count of assigned records
 =end
 
-   def get_documents o_class , **args  
-
-	query = OrientSupport::OrientQuery.new class_name(o_class), args
-	self.queries << query.compose 
-       count= 0
-       orientdb.get_documents( o_class , query: query.compose ).each{|c| records << c; count+=1 }
-       count
-   end
+    def get_records o_class , **args
+      query = OrientSupport::OrientQuery.new classname(o_class), args
+	    self.queries << query.compose
+      count = 0
+      orientdb.get_records(o_class, query: query.compose).each{|c| records << c; count += 1}
+      count
+    end
+    alias get_documents get_records
 
 =begin
-All predefined queries are send to the database.
-The result is stored in the records.
-Unknown Records are of Type ActiveOrient::Model::Myquery, uses ActiveOrient::Orientdb.execute which tries to autosuggest the ActiveOrient::Model::{Class}
+  All predefined queries are send to the database.
+  The result is stored in the records.
+  Unknown Records are of Type ActiveOrient::Model::Myquery, uses ActiveOrient::Orientdb.execute which tries to autosuggest the ActiveOrient::Model::{Class}
 
-example: Multible Records
-ach = ActiveOrient::Query.new
-ach.queries << 'create class Contracts ABSTRACT'
-ach.queries << 'create property Contracts.details link'
-ach.queries << 'create class Stocks extends Contracts'
-result = ach.execute_queries transaction: false
-
-example: Batch
-q = ActiveOrient::Query.new
-q.queries << [
-      "select expand( contracts )  from Openinterest"
-       "let con = select expand( contracts )  from Openinterest; ",
-       "let sub = select from Subcategories where contracts in $con;",
-       "let cat = select from Categories where subcategories in $sub;",
-       "let ind = select from Industries where categories in $cat;",
-       "SELECT expand(unionall) FROM (SELECT unionall( $con, $cat))"
-              ]
-q.execute_queries.each{|x|  puts "X #{x.inspect}" }
+  example: Multible Records
+    ach = ActiveOrient::Query.new
+    ach.queries << 'create class Contracts ABSTRACT'
+    ach.queries << 'create property Contracts.details link'
+    ach.queries << 'create class Stocks extends Contracts'
+    result = ach.execute_queries transaction: false
 
+  example: Batch
+    q = ActiveOrient::Query.new
+    q.queries << [
+    "select expand( contracts ) from Openinterest"
+    "let con = select expand( contracts ) from Openinterest;",
+    "let sub = select from Subcategories where contracts in $con;",
+    "let cat = select from Categories where subcategories in $sub;",
+    "let ind = select from Industries where categories in $cat;",
+    "SELECT expand(unionall) FROM (SELECT unionall( $con, $cat))"
+    ]
+    q.execute_queries.each{|x| puts "X #{x.inspect}" }
 =end
-   def execute_queries reset: true, transaction: true
-     reset_records if reset
-     begin 
-     orientdb.execute( transaction: transaction ) do 
-     result = queries.map do |q|
-       # command: words are seperated by one space only, thus squeeze multible spaces
-       sql_cmd = -> (command) { { type: "cmd", language: "sql", command: command.squeeze(' ') } }
-       batch_cmd = ->( command_array ){ {type: "script", language: "sql", script: command_array } }
-       case q
-       when String
-	 sql_cmd[ q ]
-       when Hash
-	 q
-       when Array
-	 batch_cmd[ q ]
-	else
-	  nil
-       end # case
-     end.compact 
-     # save the result in records
-     result.each{|y| records << y  }
-
-     end # block
-     rescue RestClient::InternalServerError => e
-       puts e.inspect
-     end
-
-   end # def  execute_queries
-
-end # class
 
+    def execute_queries reset: true, transaction: true
+      reset_records if reset
+      begin
+        orientdb.execute( transaction: transaction ) do
+          result = queries.map do |q|
+# command: words are seperated by one space only, thus squeeze multible spaces
+            sql_cmd = -> (command) {{type: "cmd", language: "sql", command: command.squeeze(' ') }}
+            batch_cmd = -> (command_array){{type: "script", language: "sql", script: command_array}}
+            case q
+            when String
+	            sql_cmd[q]
+            when Hash
+	            q
+            when Array
+	            batch_cmd[q]
+	          else
+	            nil
+            end # case
+          end.compact
+     # save the result in records
+          result.each{|y| records << y}
+        end # block
+      rescue RestClient::InternalServerError => e
+        puts e.inspect
+      end
+    end # def  execute_queries
+  end # class
 end # module