Class: ActiveOrient::Base

Inherits:
Object
  • Object
show all
Extended by:
ActiveModel::Callbacks, ActiveModel::Naming
Includes:
ActiveModel::Serialization, ActiveModel::Serializers::JSON, ActiveModel::Serializers::Xml, ActiveModel::Validations
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

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.



50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
 
# File 'lib/base.rb', line 50

def initialize attributes={}, opts={}
logger.progname= "ActiveOrient::Base#initialize"
#possible_link_array_candidates = link_candidates = Hash.new
@metadata = HashWithIndifferentAccess.new
#      @edges = HashWithIndifferentAccess.new
    
run_callbacks :initialize do
# puts "initialize::attributes: #{attributes.inspect}"

  attributes.keys.each do | att |
    unless att[0] == "@"     # @ identifies Metadata-attributes
      att =  att.to_sym if att.is_a?(String)    
      unless self.class.instance_methods.detect{|x| x == att }
 self.class.define_property att, nil 
#       logger.debug { "property #{att.to_s} assigned to #{self.class.to_s}" }
      else
#       logger.info{ "property #{att.to_s}  NOT assigned " }
      end
    end
  end

  if attributes['@type'] == 'd'  # document 
    @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,rid.size].split(':') 
      @metadata[ :cluster ] =  cluster.to_i
      @metadata[ :record ] = record.to_i

    end

    #### edges -- remove in_ and out_ and de-capitalize the remaining edge
    if @metadata[ :fieldTypes ].present? && (@metadata[ :fieldTypes ] =~ /=g/)
      edges = @metadata['fieldTypes'].split(',').find_all{|x| x=~/=g/}.map{|x| x.split('=').first}
      edges.each do |edge|
 operator, *base_edge =  edge.split('_')
 base_edge = base_edge.join('_')
 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 
    self.class.send :alias_method, base_edge.underscore, edge  #  
#   logger.debug { "#{link}:: edge #{edge} assigned to #{self.class.to_s} and remaped to #{base_edge.underscore}" }  

 end
      end
    end
  end


    self.attributes = attributes # set_attribute_defaults is now after_init callback
  end
  ActiveOrient::Base.store_riid self
end

Class Method Details

.attr_accessible(*args) ⇒ Object 



192
193
 
# File 'lib/base.rb', line 192

def self.attr_accessible *args
end

.attr_protected(*args) ⇒ Object

Noop methods mocking ActiveRecord::Base macros



189
190
 
# File 'lib/base.rb', line 189

def self.attr_protected *args
end

.belongs_to(model, *args) ⇒ Object

ActiveRecord::Base association API mocks



197
198
199
 
# File 'lib/base.rb', line 197

def self.belongs_to model, *args
  attr_accessor model
end

.display_riid ⇒ Object 



20
21
22
 
# File 'lib/base.rb', line 20

def self.display_riid
  @@rid_store
end

.find(*args) ⇒ Object 



214
215
216
 
# File 'lib/base.rb', line 214

def self.find *args
  []
end

.get_riid(link) ⇒ Object 



26
27
28
 
# File 'lib/base.rb', line 26

def self.get_riid link

end

.has_many(models, *args) ⇒ Object 



205
206
207
208
209
210
211
212
 
# File 'lib/base.rb', line 205

def self.has_many models, *args
  attr_accessor models

  define_method(models) do
    self.instance_variable_get("@#{models}") ||
      self.instance_variable_set("@#{models}", [])
  end
end

.has_one(model, *args) ⇒ Object 



201
202
203
 
# File 'lib/base.rb', line 201

def self.has_one model, *args
  attr_accessor model
end

.remove_riid(obj) ⇒ Object 



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

def self.remove_riid obj
  @@rid_store[obj.riid]=nil 
end

.serialize(*properties) ⇒ Object

ActiveRecord::Base misc



224
225
 
# File 'lib/base.rb', line 224

def self.serialize *properties
end

.store_riid(obj) ⇒ Object 



29
30
31
32
33
34
35
36
37
38
39
40
41
42
 
# File 'lib/base.rb', line 29

def self.store_riid obj
  if obj.rid.present? && obj.riid.all?{|x| x.present? && x>=0} # only positive values are stored
    ## return the presence of a stored object as true by the block
    ## the block is only executed if the presence is confirmed
    ##  Nothing is returned from the class-method
  if @@rid_store[obj.riid].present? 
    yield  if block_given?       
  end
   @@rid_store[obj.riid] = obj
   @@rid_store[obj.riid]  # return_value
  else
  obj # no rid-value: just return the obj
  end
end

Instance Method Details

#[](key) ⇒ Object

ActiveModel-style read/write_attribute accessors Here we define the autoload mechanism



119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
 
# File 'lib/base.rb', line 119

def [] key

  iv= attributes[key.to_sym]
  #    iv.from_orient unless iv.nil?
  if  iv.is_a?(String) && iv.rid? #&& @metadata[:fieldTypes].present? && @metadata[:fieldTypes].include?( key.to_s+"=x" )


 # puts "autoload: #{iv}"
  ActiveOrient::Model.autoload_object  iv
  elsif iv.is_a?(Array) # && @metadata[:fieldTypes].present? && @metadata[:fieldTypes].match( key.to_s+"=[znmgx]" )
 # puts "autoload: #{iv.inspect}"
  OrientSupport::Array.new self, *iv.map{|y| (y.is_a?(String) && y.rid?) ? ActiveOrient::Model.autoload_object(  y ) : y  }
  else

  if  @metadata[:fieldTypes].present? && @metadata[:fieldTypes].include?( key.to_s+"=t" ) # time
    # switch between date and datetime representation of the date-object  
    iv =~ /00:00:00/ ? Date.parse( iv ) :   DateTime.parse( iv )
  else
  iv
  end
  end
end

#[]=(key, val) ⇒ Object

Here we define how the attributes are initialized Key and val are set by the RestCliend



149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
 
# File 'lib/base.rb', line 149

def []= key, val
  val = val.rid if val.is_a? ActiveOrient::Model
#      if val.is_a?(Array) # && @metadata[:fieldTypes].present? && @metadata[:fieldTypes].include?( key.to_s+"=n" )
# if @metadata[ :fieldTypes ] =~ /out=x,in=x/
# puts "VAL is a ARRAY"
# else
#   puts "METADATA: #{ @metadata[ :fieldTypes ]}  "
# end
# val# = val.map{|x|  if val.is_a? ActiveOrient::Model then val.rid else val end }
#      end
  attributes[key.to_sym] = case val
   when Array
if  val.first.is_a?(Hash)
  v=val.map do |x| 
    if x.is_a?( Hash ) 
     HashWithIndifferentAccess.new(x)
    else
     x 
    end
  end
  OrientSupport::Array.new( self, *v )
else
  OrientSupport::Array.new( self, *val )
end
   when Hash
 HashWithIndifferentAccess.new(val) 
   else
val
   end
  
end

#attributes ⇒ Object

ActiveModel API (for serialization)



109
110
111
 
# File 'lib/base.rb', line 109

def attributes
  @attributes ||= HashWithIndifferentAccess.new
end

#attributes=(attrs) ⇒ Object 



113
114
115
 
# File 'lib/base.rb', line 113

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

#to_model ⇒ Object 



181
182
183
 
# File 'lib/base.rb', line 181

def to_model
  self
end

#update_attribute(key, value) ⇒ Object 



142
143
144
 
# File 'lib/base.rb', line 142

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