active-orient 0.6 → 0.42

data/lib/orientdb_private.rb

@@ -1,48 +0,0 @@
-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

@@ -1,330 +0,0 @@
-# Class create to manage to_orient and from_orient
-
-class Array
-  def to_orient
-    map( &:to_orient) # .join(',')
-  end
-
-  def from_orient
-    map &:from_orient
-  end
-
-  def method_missing(method, *key)
-    #if method == :to_int
-    #  return self.first 
-    #else 
-
-    unless method == :to_hash || method == :to_str #|| method == :to_int
-      return self.map{|x| x.public_send(method, *key)}
-   # end
-    end
-  end
-  # used to enable 
-  # def abc *key
-  # where key is a Range, an comma separated List or an item
-  # aimed to support #compose_where
-  def analyse
-    if first.is_a?(Range) 
-     first
-    elsif size ==1
-      first
-    else
-      self
-    end
-
-  end
-end
-
-#class RecordList
-#  def from_orient
-#      map &:from_orient
-#  end
-#end
-if RUBY_PLATFORM == 'java'
-
-## JavaMath:.BigDecimal does not premit mathematical operations
-## We convert it to RubyBigDecimal to represent it (if present in the DB) and upon loading from the DB
-
-class Java::JavaMath::BigDecimal
-  def to_f
-    BigDecimal.new self.to_s 
-  end
-
-  def from_orient
-    BigDecimal.new self.to_s
-  end
-  
-end
-  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
-  def to_a
-    [ 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
-
-  def to_a
-    [ self ]
-  end
-end
-
-class String
-  def capitalize_first_letter
-    self.sub(/^(.)/) { $1.capitalize }
-  end
-
-  def where **args
-    if rid?
-      from_orient.where **args
-    end
-  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 to_a
-    [ self ]
-  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/rest/change.rb

@@ -1,137 +0,0 @@
-module RestChange
-
-  ############### DATABASE ####################
-
-# Changes the working-database to {name}
-
-  def change_database name
-    @classes = []
-    @database = name
-    ActiveOrient.database = name
-  end
-
-  ############# OBJECTS #################
-
-=begin
-  Convient update of the dataset by calling sql-patch
-
-  The argument record can be specified as ActiveOrient::Model-instance or as rid-string( #0:0 )
-  
-  called from ModelRecord#update
-
-  if the update was successful, the updated ActiveOrient::Model-record is returned.
-=end
-
-  def update record, attributes , version=0   # :nodoc: 
-    r = if record.is_a?(String) && record.rid?
-	     ActiveOrient::Model.autoload record 
-	else
-	  record
-	end
-    return(false) unless r.is_a?(ActiveOrient::Model)
-    version = r.version if version.zero?
-    result = patch_record(r.rid) do
-      attributes.merge({'@version' => version, '@class' => r.class.ref_name })
-    end
-    # returns a new instance of ActiveOrient::Model and updates any reference on rid
-    # if the patch is not successfull no string is returned and thus no record is fetched
- #   puts JSON.parse(result) if result.is_a?(String)
-    ActiveOrient::Model.orientdb_class(name: r.class.ref_name, superclass: :find_ME ).new(JSON.parse(result))  if result.is_a?(String)
-  end
-
-
-=begin
-Example:
-  ORD.update_documents classname, set: {:symbol => 'TWR'}, where: {con_id: 340}
-
-Replaces the symbol to TWR in each record where the con_id is 340
-
-Both set and where take multiple attributes
-
-Returns the JSON-Response.
-=end
-
-  def update_records o_class, set:{}, where: {}, remove: nil
-    logger.progname = 'RestChange#UpdateRecords'
-    url = if set.present?
-      "UPDATE #{classname(o_class)} SET #{generate_sql_list(set)} #{compose_where(where)}"
-    elsif remove.present?
-      "UPDATE #{classname(o_class)} remove #{remove} #{compose_where(where)}"
-    end
-    r = @res[URI.encode("/command/#{ActiveOrient.database}/sql/" << url)].post ''
-    count_of_updated_records = (JSON.parse( r))['result'].first['value']
-     ## remove all records of the class from cache
-    ActiveOrient::Base.display_rid.delete_if{|x,y| y.is_a? o_class } if count_of_updated_records > 0 && o_class.is_a?(Class)
-    count_of_updated_records # return_value
-    rescue Exception => e
-         logger.error{e.message}
-     nil
-
-    
-  end
-
-# Lazy Updating of the given Record.
-
-  def patch_record rid	    # :nodoc:   (used by Model#update )
-    logger.progname = 'RestChange#PatchRecord'
-    content = yield
-    if content.is_a? Hash
-      begin
-        @res["/document/#{ActiveOrient.database}/#{rid}"].patch content.to_orient.to_json
-      rescue Exception => e
-        logger.error{e.message}
-      end
-    else
-  	  logger.error{"FAILED: The Block must provide an Hash with properties to be updated"}
-    end
-  end
-  alias patch_document patch_record
-
-
-  #### EXPERIMENTAL ##########
-
-=begin
-  Used to add restriction or other properties to the Property of a Class.
-  See http://orientdb.com/docs/2.1/SQL-Alter-Property.html
-=end
-
-  def alter_property o_class, property:, attribute: "DEFAULT", alteration:  # :nodoc: because untested
-    logger.progname = 'RestChange#AlterProperty'
-    begin
-      attribute.to_s! unless attribute.is_a? String
-      attribute.capitalize_first_letter
-      case attribute
-      when "LINKEDCLASS", "LINKEDTYPE", "NAME", "REGEX", "TYPE", "REGEX", "COLLATE", "CUSTOM"
-        unless alteration.is_a? String
-          logger.error{"#{alteration} should be a String."}
-          return 0
-        end
-      when "MIN", "MAX"
-        unless alteration.is_a? Integer
-          logger.error{"#{alteration} should be an Integer."}
-          return 0
-        end
-      when "MANDATORY", "NOTNULL", "READONLY"
-        unless alteration.is_a? TrueClass or alteration.is_a? FalseClass
-          logger.error{"#{alteration} should be an Integer."}
-          return 0
-        end
-      when "DEFAULT"
-      else
-        logger.error{"Wrong attribute."}
-        return 0
-      end
-
-      name_class = classname(o_class)
-      execute name_class, transaction: false do # To execute commands
-        [{ type: "cmd",
-          language: 'sql',
-          command: "ALTER PROPERTY #{name_class}.#{property} #{attribute} #{alteration}"}]
-      end
-    rescue Exception => e
-      logger.error{e.message}
-    end
-  end
-
-
-end