Class: RMXFirebaseModel

Inherits:
Object
  • Object
show all
Includes:
RMXCommonMethods
Defined in:
lib/motion/RMXFirebaseModel.rb

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(opts = nil) ⇒ RMXFirebaseModel

Returns a new instance of RMXFirebaseModel.



17
18
19
20
21
22
 
# File 'lib/motion/RMXFirebaseModel.rb', line 17

def initialize(opts=nil)
  @opts = opts
  @dependencies_cancelled = {}
  @dependencies_ready = {}
  @dependencies = {}
end

Instance Attribute Details

#api ⇒ Object (readonly)

Returns the value of attribute api.



7
8
9
 
# File 'lib/motion/RMXFirebaseModel.rb', line 7

def api
  @api
end

#opts ⇒ Object

Returns the value of attribute opts.



5
6
7
 
# File 'lib/motion/RMXFirebaseModel.rb', line 5

def opts
  @opts
end

#root ⇒ Object (readonly)

Returns the value of attribute root.



7
8
9
 
# File 'lib/motion/RMXFirebaseModel.rb', line 7

def root
  @root
end

Class Method Details

.create(&block) ⇒ Object 



169
170
171
172
173
 
# File 'lib/motion/RMXFirebaseModel.rb', line 169

def self.create(&block)
  x = new
  block.call(x)
  x
end

.get(opts = nil) ⇒ Object

this is the method you should call



176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
 
# File 'lib/motion/RMXFirebaseModel.rb', line 176

def self.get(opts=nil)
  if opts && existing = identity_map[[ className, opts ]]
    if RMXFirebase::DEBUG_IDENTITY_MAP
      p "HIT!", className, opts, existing.retainCount
    end
    return existing
  else
    if RMXFirebase::DEBUG_IDENTITY_MAP
      p "MISS!", className, opts
    end
    res = new(opts)
    if opts
      identity_map[[ className, opts ]] = res
    end
    res
  end
end

.identity_map ⇒ Object 



198
199
200
 
# File 'lib/motion/RMXFirebaseModel.rb', line 198

def self.identity_map
  @@identity_map
end

.new(opts = nil) ⇒ Object 



9
10
11
12
13
14
15
 
# File 'lib/motion/RMXFirebaseModel.rb', line 9

def self.new(opts=nil)
  x = super
  RMXFirebase::QUEUE.barrier_async do
    x.internal_setup
  end
  x
end

Instance Method Details

#always(queue = nil, &block) ⇒ Object 



132
133
134
135
136
137
138
 
# File 'lib/motion/RMXFirebaseModel.rb', line 132

def always(queue=nil, &block)
  return false if cancelled?
  if ready?
    RMXFirebase.block_on_queue(queue, self, &block)
  end
  RMX(self).on(:ready, :queue => queue, &block)
end

#always_async(&block) ⇒ Object 



128
129
130
 
# File 'lib/motion/RMXFirebaseModel.rb', line 128

def always_async(&block)
  always(:async, &block)
end

#attr(keypath) ⇒ Object 



157
158
159
 
# File 'lib/motion/RMXFirebaseModel.rb', line 157

def attr(keypath)
  root.attr(keypath)
end

#cancel_block(&block) ⇒ Object 



151
152
153
154
155
 
# File 'lib/motion/RMXFirebaseModel.rb', line 151

def cancel_block(&block)
  RMX(self).off(:ready, &block)
  RMX(self).off(:cancelled, &block)
  RMX(self).off(:finished, &block)
end

#cancelled! ⇒ Object 



52
53
54
55
56
57
58
 
# File 'lib/motion/RMXFirebaseModel.rb', line 52

def cancelled!
  RMXFirebase::QUEUE.barrier_async do
    @cancelled = true
    RMX(self).trigger(:cancelled, self)
    RMX(self).trigger(:finished, self)
  end
end

#cancelled? ⇒ Boolean

Returns:

  • (Boolean) 


35
36
37
 
# File 'lib/motion/RMXFirebaseModel.rb', line 35

def cancelled?
  !!@cancelled
end

#check_ready ⇒ Object 



75
76
77
78
79
80
81
82
83
84
 
# File 'lib/motion/RMXFirebaseModel.rb', line 75

def check_ready
  RMX(self).require_queue!(RMXFirebase::QUEUE, __FILE__, __LINE__) if RMX::DEBUG_QUEUES
  # p "check_ready cancelled?", @api.cancelled?, dependencies_cancelled.size
  # p "check_ready ready?", @api.ready?, dependencies_ready.size, dependencies.size
  if @api.cancelled? || @dependencies_cancelled.size > 0
    cancelled!
  elsif @api.ready? && @dependencies_ready.size == @dependencies.size
    ready!
  end
end

#dealloc ⇒ Object 



24
25
26
27
28
29
 
# File 'lib/motion/RMXFirebaseModel.rb', line 24

def dealloc
  if RMXFirebase::DEBUG_MODEL_DEALLOC
    p " - dealloc!"
  end
  super
end

#depend(name, model) ⇒ Object

add another model as a dependency and ivar, which will affect ready. should be done before ready has has a chance to be triggered. the user can add an attr_reader for easy access if desired.

Book

attr_reader :author
model.watch(:root, ref) do |data|
  model.depend(:author, Author.get(data[:author_id]))
end

… book = Book.get(1) book.attr(“name”) #=> “My Book” book.author.attr(“name”) #=> “Joe Noon”



105
106
107
108
109
110
111
112
113
114
115
 
# File 'lib/motion/RMXFirebaseModel.rb', line 105

def depend(name, model)
  RMX(self).require_queue!(RMXFirebase::QUEUE, __FILE__, __LINE__) if RMX::DEBUG_QUEUES
  @dependencies[name] = model
  RMX(self).ivar(name, model)
  track_dependency_state(model)
  RMX(model).on(:finished, :queue => RMXFirebase::QUEUE) do |_model|
    RMX(self).require_queue!(RMXFirebase::QUEUE, __FILE__, __LINE__) if RMX::DEBUG_QUEUES
    track_dependency_state(_model)
    check_ready
  end
end

#finished? ⇒ Boolean

Returns:

  • (Boolean) 


39
40
41
 
# File 'lib/motion/RMXFirebaseModel.rb', line 39

def finished?
  ready? || cancelled?
end

#hasValue? ⇒ Boolean

Returns:

  • (Boolean) 


161
162
163
 
# File 'lib/motion/RMXFirebaseModel.rb', line 161

def hasValue?
  root.hasValue?
end

#internal_setup ⇒ Object 



64
65
66
67
68
69
70
71
72
73
 
# File 'lib/motion/RMXFirebaseModel.rb', line 64

def internal_setup
  RMX(self).require_queue!(RMXFirebase::QUEUE, __FILE__, __LINE__) if RMX::DEBUG_QUEUES
  @api = RMXFirebaseCoordinator.new
  RMX(@api).on(:finished, :queue => RMXFirebase::QUEUE) do
    RMX(self).require_queue!(RMXFirebase::QUEUE, __FILE__, __LINE__) if RMX::DEBUG_QUEUES
    check_ready
  end
  RMX(self).on(:cancelled, :exclusive => [ :ready, :finished ], :queue => :async)
  setup
end

#once(queue = nil, &block) ⇒ Object 



140
141
142
143
144
145
146
147
148
149
 
# File 'lib/motion/RMXFirebaseModel.rb', line 140

def once(queue=nil, &block)
  RMXFirebase::QUEUE.barrier_async do
    if ready? || cancelled?
      RMXFirebase.block_on_queue(queue, self, &block)
    else
      RMX(self).once(:ready, :strong => true, :queue => queue, &block)
    end
  end
  self
end

#ready! ⇒ Object 



43
44
45
46
47
48
49
50
 
# File 'lib/motion/RMXFirebaseModel.rb', line 43

def ready!
  RMXFirebase::QUEUE.barrier_async do
    # p "ready!"
    @ready = true
    RMX(self).trigger(:ready, self)
    RMX(self).trigger(:finished, self)
  end
end

#ready? ⇒ Boolean

Returns:

  • (Boolean) 


31
32
33
 
# File 'lib/motion/RMXFirebaseModel.rb', line 31

def ready?
  !!@ready
end

#setup ⇒ Object

override



61
62
 
# File 'lib/motion/RMXFirebaseModel.rb', line 61

def setup
end

#toValue ⇒ Object 



165
166
167
 
# File 'lib/motion/RMXFirebaseModel.rb', line 165

def toValue
  root.toValue
end

#track_dependency_state(model) ⇒ Object 



117
118
119
120
121
122
123
124
125
126
 
# File 'lib/motion/RMXFirebaseModel.rb', line 117

def track_dependency_state(model)
  RMX(self).require_queue!(RMXFirebase::QUEUE, __FILE__, __LINE__) if RMX::DEBUG_QUEUES
  if model.ready?
    @dependencies_ready[model] = true
    @dependencies_cancelled.delete(model)
  elsif model.cancelled?
    @dependencies_cancelled[model] = true
    @dependencies_ready.delete(model)
  end
end

#watch(name, ref, opts = {}, &block) ⇒ Object 



86
87
88
89
 
# File 'lib/motion/RMXFirebaseModel.rb', line 86

def watch(name, ref, opts={}, &block)
  RMX(self).require_queue!(RMXFirebase::QUEUE, __FILE__, __LINE__) if RMX::DEBUG_QUEUES
  RMX(self).ivar(name, @api.watch(name, ref, opts, &block))
end