rmx-firebase 0.0.2

data/lib/motion/RMXFirebaseCollection.rb

@@ -0,0 +1,372 @@
+class RMXFirebaseCollection
+
+  include RMXCommonMethods
+
+  attr_reader :ref, :snaps
+
+  # public
+  def ready?
+    !!@ready
+  end
+
+  # public
+  def cancelled?
+    !!@cancelled
+  end
+
+  # overridable
+  def transform(snap)
+    if block = @transform_block
+      block.call(snap)
+    else
+      snap
+    end
+  end
+
+  def transformed_async(&block)
+    transformed(:async, &block)
+  end
+
+  # public, completes with ready transformations
+  def transformed(queue=nil, &block)
+    items = @transformations.dup
+    if (snap = items.first) && snap.is_a?(RMXFirebaseModel)
+      RMXFirebaseBatch.new(items).once(queue, &block)
+    else
+      RMXFirebase.block_on_queue(queue, items, &block)
+    end
+    self
+  end
+
+  def once_async(&block)
+    once(:async, &block)
+  end
+
+  # completes with `self` once, when the collection is ready.
+  # retains `self` and the sender until complete
+  def once(queue=nil, &block)
+    RMXFirebase::QUEUE.barrier_async do
+      if ready?
+        RMXFirebase.block_on_queue(queue, self, &block)
+      else
+        RMX(self).once(:ready, :strong => true, :queue => queue, &block)
+      end
+    end
+    self
+  end
+
+  def always_async(&block)
+    always(:async, &block)
+  end
+
+  # completes with `self` immediately if ready, and every time the collection :ready fires.
+  # does not retain `self` or the sender.
+  # returns an "unbinder" that can be called to stop listening.
+  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
+
+  # completes with `self` every time the collection :changed fires.
+  # does not retain `self` or the sender.
+  # returns an "unbinder" that can be called to stop listening.
+  def changed(queue=nil, &block)
+    return false if cancelled?
+    RMX(self).on(:changed, :queue => queue, &block)
+  end
+
+  # completes with `self`, `snap`, `prev` every time the collection :added fires.
+  # does not retain `self` or the sender.
+  # returns an "unbinder" that can be called to stop listening.
+  def added(queue=nil, &block)
+    return false if cancelled?
+    RMX(self).on(:added, :queue => queue, &block)
+  end
+
+  # completes with `self`, `snap` every time the collection :removed fires.
+  # does not retain `self` or the sender.
+  # returns an "unbinder" that can be called to stop listening.
+  def removed(queue=nil, &block)
+    return false if cancelled?
+    RMX(self).on(:removed, :queue => queue, &block)
+  end
+
+  # completes with `self`, `snap`, `prev` every time the collection :moved fires.
+  # does not retain `self` or the sender.
+  # returns an "unbinder" that can be called to stop listening.
+  def moved(queue=nil, &block)
+    return false if cancelled?
+    RMX(self).on(:moved, :queue => queue, &block)
+  end
+
+  def self.new(ref)
+    x = super()
+    RMXFirebase::QUEUE.barrier_async do
+      x.setup_ref(ref)
+    end
+    x
+  end
+
+  # internal
+  def initialize
+    @snaps_by_name = {}
+    @snaps = []
+    @transformations_table = {}
+    @transformations = []
+  end
+
+  # internal
+  def setup_ref(_ref)
+    RMX(self).require_queue!(RMXFirebase::QUEUE, __FILE__, __LINE__) if RMX::DEBUG_QUEUES
+    _clear_current_ref!
+    @ref = _ref
+    @ready = false
+    @cancelled = false
+    cancel_block = lambda do |err|
+      @cancelled = err
+      cancelled!
+    end
+    @added_handler = @ref.on(:added) do |snap, prev|
+      # p "NORMAL ", snap.name, prev
+      RMXFirebase::QUEUE.barrier_async do
+        # p "BARRIER", snap.name, prev
+        add(snap, prev)
+      end
+    end
+    @removed_handler = @ref.on(:removed) do |snap|
+      RMXFirebase::QUEUE.barrier_async do
+        remove(snap)
+      end
+    end
+    @moved_handler = @ref.on(:moved) do |snap, prev|
+      RMXFirebase::QUEUE.barrier_async do
+        add(snap, prev)
+      end
+    end
+    @value_handler = @ref.once(:value, { :disconnect => cancel_block }) do |collection|
+      @value_handler = nil
+      RMXFirebase::QUEUE.barrier_async do
+        ready!
+      end
+    end
+    RMX(self).on(:cancelled, :exclusive => [ :ready, :finished, :changed, :added, :removed, :moved ], :queue => :async)
+  end
+
+  def refresh_order!
+    RMXFirebase::QUEUE.barrier_async do
+      next unless @ref
+      if @added_handler
+        @ref.off(@added_handler)
+        @added_handler = nil
+      end
+      @added_handler = @ref.on(:added) do |snap, prev|
+        # p "NORMAL ", snap.name, prev
+        RMXFirebase::QUEUE.barrier_async do
+          # p "BARRIER", snap.name, prev
+          add(snap, prev)
+        end
+      end
+    end
+  end
+
+  # mess up the order on purpose
+  def _test_scatter!
+    RMXFirebase::QUEUE.barrier_async do
+      _snaps = @snaps.dup
+      p "before scatter", @snaps.map(&:name)
+      p "before scatter snaps_by_name", @snaps_by_name
+
+      _snaps.each do |snap|
+        others = _snaps - [ snap ]
+        random = others.sample
+        add(snap, random.name)
+      end
+    end
+  end
+
+  def rmx_dealloc
+    _clear_current_ref!
+  end
+
+  def _clear_current_ref!
+    if @ref
+      if @added_handler
+        @ref.off(@added_handler)
+        @added_handler = nil
+      end
+      if @removed_handler
+        @ref.off(@removed_handler)
+        @removed_handler = nil
+      end
+      if @moved_handler
+        @ref.off(@moved_handler)
+        @moved_handler = nil
+      end
+      if @value_handler
+        @ref.off(@value_handler)
+        @value_handler = nil
+      end
+      @ref = nil
+    end
+  end
+
+
+  # internal
+  def ready!
+    RMXFirebase::QUEUE.barrier_async do
+      @ready = true
+      RMX(self).trigger(:ready, self)
+      RMX(self).trigger(:changed, self)
+      RMX(self).trigger(:finished, self)
+    end
+  end
+
+  # internal
+  def cancelled!
+    RMXFirebase::QUEUE.barrier_async do
+      @cancelled = true
+      RMX(self).trigger(:cancelled, self)
+      RMX(self).trigger(:finished, self)
+    end
+  end
+
+  # internal, allows the user to pass a block for transformations instead of subclassing
+  # and overriding #transform, for one-off cases
+  def transform=(block)
+    if block
+      @transform_block = RMX.safe_block(block)
+    else
+      @transform_block = nil
+    end
+  end
+
+  # internal
+  def store_transform(snap)
+    RMX(self).require_queue!(RMXFirebase::QUEUE, __FILE__, __LINE__) if RMX::DEBUG_QUEUES
+    @transformations_table[snap] ||= transform(snap)
+  end
+
+  def _log_snap_names
+    RMXFirebase::QUEUE.barrier_async do
+      puts "snaps_by_name:"
+      _log_hash(@snaps_by_name)
+    end
+  end
+
+
+  def _log_hash(hash)
+    hash.to_a.sort_by { |x| x[1] }.each do |pair|
+      puts pair.inspect
+    end
+  end
+
+  # internal
+  def add(snap, prev)
+    RMX(self).require_queue!(RMXFirebase::QUEUE, __FILE__, __LINE__) if RMX::DEBUG_QUEUES
+    moved = false
+
+    if current_index = @snaps_by_name[snap.name]
+      if current_index == 0 && prev.nil?
+        return
+      elsif current_index > 0 && prev && @snaps_by_name[prev] == current_index - 1
+        return
+      end
+      moved = true
+      @snaps.delete_at(current_index)
+      @transformations.delete_at(current_index)
+      if was_index = @snaps_by_name.delete(snap.name)
+        @snaps_by_name.keys.each do |k|
+          v = @snaps_by_name[k]
+          if v > was_index
+            @snaps_by_name[k] -= 1
+          end
+        end
+      end
+      # raise if snaps_by_name.values.uniq.size != snaps_by_name.values.size
+    end
+    # raise if snaps_by_name.values.uniq.size != snaps_by_name.values.size
+    if prev && (index = @snaps_by_name[prev])
+      new_index = index + 1
+      @snaps.insert(new_index, snap)
+      @transformations.insert(new_index, store_transform(snap))
+      @snaps_by_name.keys.each do |k|
+        v = @snaps_by_name[k]
+        if v >= new_index
+          @snaps_by_name[k] += 1
+        end
+      end
+      @snaps_by_name[snap.name] = new_index
+      # raise if snaps_by_name.values.uniq.size != snaps_by_name.values.size
+    else
+      @snaps.unshift(snap)
+      @transformations.unshift(store_transform(snap))
+      @snaps_by_name.keys.each do |k|
+        v = @snaps_by_name[k]
+        @snaps_by_name[k] += 1
+      end
+      @snaps_by_name[snap.name] = 0
+      # raise if snaps_by_name.values.uniq.size != snaps_by_name.values.size
+    end
+    if moved
+      RMX(self).trigger(:moved, self, snap, prev)
+    else
+      RMX(self).trigger(:added, self, snap, prev)
+    end
+    RMX(self).trigger(:changed, self)
+    if ready?
+      RMX(self).trigger(:ready, self)
+      RMX(self).trigger(:finished, self)
+    end
+  end
+
+  # internal
+  def remove(snap)
+    if current_index = @snaps_by_name[snap.name]
+      @snaps.delete_at(current_index)
+      @transformations.delete_at(current_index)
+      @snaps_by_name.keys.each do |k|
+        v = @snaps_by_name[k]
+        if v > current_index
+          @snaps_by_name[k] -= 1
+        end
+      end
+      RMX(self).trigger(:removed, self, snap)
+      RMX(self).trigger(:changed, self)
+      if ready?
+        RMX(self).trigger(:ready, self)
+        RMX(self).trigger(:finished, self)
+      end
+    end
+  end
+
+  # this is the method you should call
+  def self.get(ref)
+    if ref && existing = identity_map[[ className, ref.description ]]
+      if RMXFirebase::DEBUG_IDENTITY_MAP
+        p "HIT!", className, ref.description, existing.retainCount
+      end
+      return existing
+    else
+      if RMXFirebase::DEBUG_IDENTITY_MAP
+        p "MISS!", className, ref.description
+      end
+      res = new(ref)
+      if ref
+        identity_map[[ className, ref.description ]] = res
+      end
+      res
+    end
+  end
+
+  Dispatch.once do
+    @@identity_map = RMXSynchronizedStrongToWeakHash.new
+  end
+
+  def self.identity_map
+    @@identity_map
+  end
+
+end

data/lib/motion/RMXFirebaseCoordinator.rb

@@ -0,0 +1,109 @@
+class RMXFirebaseCoordinator
+
+  include RMXCommonMethods
+
+  attr_reader :watches
+
+  def initialize
+    @watches = {}
+  end
+
+  def clear!
+    RMXFirebase::QUEUE.barrier_async do
+      @cancelled = false
+      @ready = false
+      keys = watches.keys.dup
+      while keys.size > 0
+        name = keys.shift
+        watch = watches[name]
+        watch.stop!
+      end
+      watches.clear
+    end
+    self
+  end
+
+  def ready?
+    !!@ready
+  end
+
+  def cancelled?
+    !!@cancelled
+  end
+
+  def ready!
+    RMXFirebase::QUEUE.barrier_async do
+      @ready = true
+      RMX(self).trigger(:ready, self)
+      RMX(self).trigger(:finished, self)
+    end
+  end
+
+  def cancelled!
+    RMXFirebase::QUEUE.barrier_async do
+      @cancelled = true
+      RMX(self).trigger(:cancelled, self)
+      RMX(self).trigger(:finished, self)
+    end
+  end
+
+  def stub(name)
+    RMX(self).require_queue!(RMXFirebase::QUEUE, __FILE__, __LINE__) if RMX::DEBUG_QUEUES
+    watches[name] ||= RMXFirebaseListener.new
+  end
+
+  def watch(name, ref, opts={}, &block)
+    RMX(self).require_queue!(RMXFirebase::QUEUE, __FILE__, __LINE__) if RMX::DEBUG_QUEUES
+    data = RMXFirebaseListener.new
+    data.ref = ref
+    if opts[:required]
+      data.value_required = true
+    end
+    unless block.nil?
+      data.callback = block.weak!
+      data.callback_owner = block.owner
+    end
+    if current = watches[name]
+      if current == data || current.description == data.description
+        return
+      end
+      current.stop!
+      RMX(current).off(:finished, self)
+    end
+    watches[name] = data
+    RMX(data).on(:finished, :queue => RMXFirebase::QUEUE) do
+      RMX(self).require_queue!(RMXFirebase::QUEUE, __FILE__, __LINE__) if RMX::DEBUG_QUEUES
+      readies = 0
+      cancelled = 0
+      size = watches.size
+      watches.each_pair do |k, v|
+        if v.ready?
+          readies += 1
+        elsif v.cancelled?
+          cancelled += 1
+          break
+        end
+      end
+      if cancelled > 0
+        cancelled!
+      elsif readies == size
+        ready!
+      end
+    end
+    data.start!
+    data
+  end
+
+  def attr(keypath)
+    valueForKeyPath(keypath)
+  end
+
+  def valueForKey(key)
+    watches[key]
+  end
+
+  def valueForUndefinedKey(key)
+    nil
+  end
+
+end

data/lib/motion/RMXFirebaseDataSnapshot.rb

@@ -0,0 +1,53 @@
+class RMXFirebaseDataSnapshot
+
+  include RMXCommonMethods
+
+  attr_accessor :snap
+
+  def initialize(snap)
+    @snap = snap
+  end
+
+  def hasValue?
+    !value.nil?
+  end
+
+  def attr(keypath)
+    valueForKeyPath(keypath)
+  end
+
+  def valueForKey(key)
+    if v = value
+      v[key]
+    end
+  end
+
+  def valueForUndefinedKey(key)
+    nil
+  end
+
+  def value
+    snap.value
+  end
+
+  def ref
+    snap.ref
+  end
+
+  def name
+    snap.name
+  end
+
+  def priority
+    snap.priority
+  end
+
+  def count
+    snap.childrenCount
+  end
+
+  def children
+    snap.children.each.map { |x| RMXFirebaseDataSnapshot.new(x) }
+  end
+
+end

data/lib/motion/RMXFirebaseHandleModel.rb

@@ -0,0 +1,10 @@
+module RMXFirebaseHandleModel
+  def handle(key)
+    define_method(key) do
+      self.model
+    end
+    define_method("#{key}=") do |val|
+      self.model = val
+    end
+  end
+end

data/lib/motion/RMXFirebaseListener.rb

@@ -0,0 +1,76 @@
+class RMXFirebaseListener
+
+  include RMXCommonMethods
+
+  attr_accessor :snapshot, :ref, :callback, :handle, :value_required
+  RMX(self).weak_attr_accessor :callback_owner
+
+  def rmx_dealloc
+    if ref && handle
+      ref.off(handle)
+    end
+  end
+
+  def ready?
+    !!@ready
+  end
+
+  def cancelled?
+    !!@cancelled
+  end
+
+  def start!
+    RMX(self).require_queue!(RMXFirebase::QUEUE, __FILE__, __LINE__) if RMX::DEBUG_QUEUES
+    cancel_block = lambda do |err|
+      @cancelled = err
+      RMX(self).trigger(:cancelled, self)
+      RMX(self).trigger(:finished, self)
+    end
+    @handle = ref.on(:value, { :disconnect => cancel_block }) do |snap|
+      RMXFirebase::QUEUE.barrier_async do
+        @snapshot = snap
+        if value_required && !snap.hasValue?
+          cancel_block.call(NSError.errorWithDomain("requirement failure", code:0, userInfo:{
+            :error => "requirement_failure"
+          }))
+        else
+          callback.call(snap) if callback && callback_owner
+          @ready = true
+          RMX(self).trigger(:ready, self)
+          RMX(self).trigger(:finished, self)
+          # p "ready__"
+        end
+      end
+    end
+  end
+
+  def stop!
+    RMX(self).require_queue!(RMXFirebase::QUEUE, __FILE__, __LINE__) if RMX::DEBUG_QUEUES
+    @cancelled = false
+    @ready = false
+    if ref && handle
+      ref.off(handle)
+    end
+  end
+
+  def hasValue?
+    !!(snapshot && snapshot.hasValue?)
+  end
+
+  def toValue
+    snapshot && snapshot.value
+  end
+
+  def attr(keypath)
+    valueForKeyPath(keypath)
+  end
+
+  def valueForKey(key)
+    snapshot && snapshot.valueForKey(key)
+  end
+
+  def valueForUndefinedKey(key)
+    nil
+  end
+
+end