Class: ActiveOrient::Base

Inherits:
Object show all
Extended by:
ActiveModel::Callbacks, ActiveModel::Naming
Includes:
ActiveModel::Serialization, ActiveModel::Serializers::JSON, ActiveModel::Validations, Conversions, OrientDB
Defined in:
lib/base.rb

Overview

Base class for tableless IB data Models, extends ActiveModel API

Direct Known Subclasses

Model

Constant Summary collapse

@@rid_store =

Every Rest::Base-Object is stored in the @@rid_store

The Objects are just references to the @@rid_store.
Any Change of the Object is thus synchonized to any allocated variable.

Hash.new

Constants included from OrientDB

OrientDB::DocumentDatabase, OrientDB::DocumentDatabasePool, OrientDB::DocumentDatabasePooled, OrientDB::GraphDatabase, OrientDB::IndexType, OrientDB::OClassImpl, OrientDB::OTraverse, OrientDB::PropertyImpl, OrientDB::RemoteStorage, OrientDB::SQLCommand, OrientDB::SQLSynchQuery, OrientDB::Schema, OrientDB::SchemaProxy, OrientDB::SchemaType, OrientDB::ServerAdmin, OrientDB::User, OrientDB::UsingJava

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(attributes = {}, opts = {}) ⇒ Base

If a opts hash is given, keys are taken as attribute names, values as data. The model instance fields are then set automatically from the opts Hash.



91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
 
# File 'lib/base.rb', line 91

def initialize attributes = {}, opts = {}
  logger.progname = "ActiveOrient::Base#initialize"
  @metadata = Hash.new # HashWithIndifferentAccess.new
  @d =  nil
  run_callbacks :initialize do
    if RUBY_PLATFORM == 'java' && attributes.is_a?( Document )
      @d = attributes
      attributes =  @d.values
      @metadata[:class]      = @d.class_name
      @metadata[:version]    = @d.version
      @metadata[:cluster], @metadata[:record] = @d.rid[1,@d.rid.size].split(':')
      puts "Metadata:  #{@metadata}"
    end

    # transform $current to :current and $current.mgr to :mgr
     transformers = attributes.keys.map{|x|  [x, x[1..-1].split(".").last.to_sym] if x[0] == '$'}.compact
     # transformers:  [ [original key, modified key] , [] ]
     transformers.each do |a|
       attributes[a.last] = attributes[a.first]
       attributes.delete a.first
     end

    attributes.keys.each do |att|
      unless att[0] == "@" # @ identifies Metadata-attributes
        unless self.class.instance_methods.detect{|x| x == att.to_sym}
          self.class.define_property att.to_sym, nil
        else
          #logger.info{"Property #{att.to_s} NOT assigned"}
        end
      end
    end
    if attributes['@type'] == 'd'  # document via REST
      @metadata[:type]       = attributes.delete '@type'
      @metadata[:class]      = attributes.delete '@class'
      @metadata[:version]    = attributes.delete '@version'
      @metadata[:fieldTypes] = attributes.delete '@fieldTypes'
      
      if attributes.has_key?('@rid')
        rid = attributes.delete '@rid'
        cluster, record = rid[1 .. -1].split(':')
        @metadata[:cluster] = cluster.to_i
        @metadata[:record]  = record.to_i
      end

      if @metadata[:fieldTypes ].present? && (@metadata[:fieldTypes] =~ /=g/)
        @metadata[:edges] = { :in => [], :out => [] }
        edges = @metadata[:fieldTypes].split(',').find_all{|x| x=~/=g/}.map{|x| x.split('=').first}
        #  puts "Detected EDGES: #{edges.inspect}"
        edges.each do |edge|
          operator, *base_edge = edge.split('_')
          base_edge = base_edge.join('_')
          @metadata[:edges][operator.to_sym] << base_edge
        end
        #    unless self.class.instance_methods.detect{|x| x == base_edge}
        #      ## define two methods: out_{Edge}/in_{Edge} -> edge.
        #      self.class.define_property base_edge, nil
        #      allocate_edge_method = -> (edge)  do
        #        unless (ee=db.get_db_superclass(edge)) == "E"
        #          allocate_edge_method[ee]
        #          self.class.send :alias_method, base_edge.underscore, edge
        #      ## define inherented classes, tooa
        #      

        #    end
        #  end
      end
    end
    self.attributes = attributes # set_attribute_defaults is now after_init callback
  end
  #      puts "Storing #{self.rid} to rid-store"
  #      ActiveOrient::Base.store_rid( self ) do | cache_obj|
  #   cache_obj.reload! self
  #      end
end

Instance Attribute Details

#metadata ⇒ Object (readonly)

Used to read the metadata



24
25
26
 
# File 'lib/base.rb', line 24

def metadata
  @metadata
end

Class Method Details

.attr_accessible(*args) ⇒ Object 



258
259
 
# File 'lib/base.rb', line 258

def self.attr_accessible *args
end

.attr_protected(*args) ⇒ Object

Noop methods mocking ActiveRecord::Base macros



255
256
 
# File 'lib/base.rb', line 255

def self.attr_protected *args
end

.belongs_to(model, *args) ⇒ Object

ActiveRecord::Base association API mocks



263
264
265
 
# File 'lib/base.rb', line 263

def self.belongs_to model, *args # :nodoc:
  attr_accessor model
end

.display_rid ⇒ Object 



33
34
35
 
# File 'lib/base.rb', line 33

def self.display_rid
  @@rid_store
end

.exclude_the_following_properties(*args) ⇒ Object

Exclude some properties from loading via get, reload!, get_document, get_record



285
286
287
288
289
 
# File 'lib/base.rb', line 285

def self.exclude_the_following_properties *args
  puts "excluding #{args}"
@excluded =  (@excluded.is_a?( Array))?  @excluded + args : args
  puts "#{self.inspect} --> excluded #{@excluded}"
end

.get_rid(rid) ⇒ Object 



49
50
51
52
 
# File 'lib/base.rb', line 49

def self.get_rid rid
  rid =  rid[1..-1] if rid[0]=='#'
  @@rid_store[rid] 
end

.has_many(models, *args) ⇒ Object

:nodoc:



271
272
273
274
275
276
 
# File 'lib/base.rb', line 271

def self.has_many models, *args  # :nodoc:
  attr_accessor models
  define_method(models) do
    self.instance_variable_get("@#{models}") || self.instance_variable_set("@#{models}", [])
  end
end

.has_one(model, *args) ⇒ Object

:nodoc:



267
268
269
 
# File 'lib/base.rb', line 267

def self.has_one model, *args   # :nodoc:
  attr_accessor model
end

.remove_rid(obj) ⇒ Object

removes an Item from the cache

obj has to provide a method #rid

thus a string or a Model-Object is accepted



45
46
47
 
# File 'lib/base.rb', line 45

def self.remove_rid obj
  @@rid_store.delete obj.rid if obj.rid.present?
end

.reset_rid_store ⇒ Object 



54
55
56
 
# File 'lib/base.rb', line 54

def self.reset_rid_store
  @@rid_store = Hash.new
end

.serialize(*properties) ⇒ Object

ActiveRecord::Base misc



292
293
 
# File 'lib/base.rb', line 292

def self.serialize *properties # :nodoc:
end

.store_rid(obj) ⇒ Object

Stores the obj in the cache.

If the cache-value exists, it is updated by the data provided in obj and the cached obj is returned



65
66
67
68
69
70
71
72
73
74
75
76
 
# File 'lib/base.rb', line 65

def self.store_rid obj
  if obj.rid.present? && obj.rid.rid?
   if @@rid_store[obj.rid].present?
  @@rid_store[obj.rid].transfer_content from: obj
    else
     @@rid_store[obj.rid] =   obj
    end
   @@rid_store[obj.rid] 
  else
  nil 
  end
end

Instance Method Details

#[](key) ⇒ Object

ActiveModel-style read/write_attribute accessors

Autoload mechanism and data conversion are defined in the method "from_orient" of each class



200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
 
# File 'lib/base.rb', line 200

def [] key

  iv = attributes[key]
  if my_metadata( key: key) == "t"
    iv =~ /00:00:00/ ? Date.parse(iv) : DateTime.parse(iv)
  elsif my_metadata( key: key) == "x"
    iv = ActiveOrient::Model.autoload_object iv
  elsif iv.is_a? Array
    OrientSupport::Array.new( work_on: self, work_with: iv.from_orient){ key.to_sym }
  elsif iv.is_a? Hash
#       if iv.keys.include?("@class" )
#       ActiveOrient::Model.orientdb_class( name: iv["@class"] ).new iv
#       else
#         iv
    OrientSupport::Hash.new( self, iv.from_orient){ key.to_sym }
  #      end
    #     elsif iv.is_a? RecordMap 
    #      iv
    #       puts "RecordSet detected"
  else
    iv.from_orient
  end
end

#[]=(key, val) ⇒ Object 



224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
 
# File 'lib/base.rb', line 224

def []= key, val
  val = val.rid if val.is_a?( ActiveOrient::Model ) && val.rid.rid?
  attributes[key.to_sym] = case val
                           when Array
                             if val.first.is_a?(Hash)
                               v = val.map{ |x| x }
                               OrientSupport::Array.new(work_on: self, work_with: v )
                             else
                               OrientSupport::Array.new(work_on: self, work_with: val )
                             end
                           when Hash
                             if val.keys.include?("@class" )
                               OrientSupport::Array.new( work_on: self, work_with: val.from_orient){ key.to_sym }
                             else
                               OrientSupport::Hash.new( self, val  )
                             end
                           else
                             val
                           end
end

#attributes ⇒ Object 



173
174
175
 
# File 'lib/base.rb', line 173

def attributes
  @attributes ||= Hash.new # WithIndifferentAccess.new
end

#attributes=(attrs) ⇒ Object 



177
178
179
 
# File 'lib/base.rb', line 177

def attributes= attrs
  attrs.keys.each{|key| self.send("#{key}=", attrs[key])}
end

#included_links ⇒ Object

ActiveModel API (for serialization)



168
169
170
171
 
# File 'lib/base.rb', line 168

def included_links
  meta= Hash[ @metadata[:fieldTypes].split(',').map{|x| x.split '='} ]
  meta.map{|x,y| x if y=='x'}.compact
end

#my_metadata(key: nil, symbol: nil) ⇒ Object 



181
182
183
184
185
186
187
188
189
190
191
192
 
# File 'lib/base.rb', line 181

def my_metadata key: nil, symbol: nil
  if @metadata[:fieldTypes].present?  
    meta= Hash[ @metadata[:fieldTypes].split(',').map{|x| x.split '='} ]
    if key.present?
      meta[key.to_s]
    elsif symbol.present?
      meta.map{|x,y| x if y == symbol.to_s }.compact
    else
      meta
    end
  end
end

#to_model ⇒ Object

:nodoc:



249
250
251
 
# File 'lib/base.rb', line 249

def to_model   # :nodoc:
  self
end

#update_attribute(key, value) ⇒ Object 



245
246
247
 
# File 'lib/base.rb', line 245

def update_attribute key, value
  @attributes[key] = value
end