rmx-firebase 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: e1d4fa77899f71b7fcf8ab6349245bb008b65f4d
+  data.tar.gz: 2076ec5160ae4c60a402b94db77714b9796ff4cc
+SHA512:
+  metadata.gz: 187ab0df77bf3026ff184ddf87c42b77265bc8f1592ff2f214d5412386800db64310f0a5c5a05875213e4456911b08bf0b23bde02d971024fecc354ae95ef4d0
+  data.tar.gz: ff8bfed7d390c6d6196d291ea86ad370f123ffe7b1b6ec79e6162d02b632bcd8d2fb5b2d67eb549e8d3e0f4bdd45d85fff1e65e6d091b4c198a7018277c09454

data/.gitignore

@@ -0,0 +1,20 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+build
+build*
+*.bridgesupport

data/Gemfile

@@ -0,0 +1,7 @@
+source 'https://rubygems.org'
+
+group :test, :development do
+  gem 'rake'
+end
+
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Joe Noon
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,11 @@
+RMXFirebase
+-----------
+
+Work in progress firebase wrapper:
+
+Goals:
+
+1. Shorter methods
+2. Simplify common access patterns
+3. Provide an API that makes it hard to leak
+4. Identity map of data snapshots in-use, for faster access

data/Rakefile

@@ -0,0 +1,18 @@
+require "bundler/gem_tasks"
+if ENV['rubymotion']
+  $:.unshift('/Library/RubyMotion/lib')
+  if ENV.fetch('platform', 'ios') == 'ios'
+    require 'motion/project/template/ios'
+  elsif ENV['platform'] == 'osx'
+    require 'motion/project/template/osx'
+  else
+    raise "Unsupported platform #{ENV['platform']}"
+  end
+  require 'bundler'
+  Bundler.require
+
+  Motion::Project::App.setup do |app|
+    # Use `rake config' to see complete project settings.
+    app.name = 'rmx-firebase'
+  end
+end

data/app/app_delegate.rb

@@ -0,0 +1,5 @@
+class AppDelegate
+  def application(application, didFinishLaunchingWithOptions:launchOptions)
+    true
+  end
+end

data/lib/motion/FQuery+RMXFirebase.rb

@@ -0,0 +1,178 @@
+class FQuery
+
+  EVENT_TYPES_MAP = {
+    :child_added => FEventTypeChildAdded,
+    :added => FEventTypeChildAdded,
+    :child_moved => FEventTypeChildMoved,
+    :moved => FEventTypeChildMoved,
+    :child_changed => FEventTypeChildChanged,
+    :changed => FEventTypeChildChanged,
+    :child_removed => FEventTypeChildRemoved,
+    :removed => FEventTypeChildRemoved,
+    :value => FEventTypeValue
+  }
+
+  def rmx_object_desc
+    "#{super}:#{description}"
+  end
+
+  def limited(limit)
+    queryLimitedToNumberOfChildren(limit)
+  end
+
+  def starting_at(priority)
+    queryStartingAtPriority(priority)
+  end
+
+  def ending_at(priority)
+    queryEndingAtPriority(priority)
+  end
+
+  def on(_event_type, options={}, &and_then)
+    and_then ||= options[:completion]
+    raise "event handler is required" unless and_then
+    raise "event handler must accept one or two arguments" unless and_then.arity == 1 || and_then.arity == 2
+    completion = RMX.safe_block(and_then)
+
+    event_type = EVENT_TYPES_MAP[_event_type]
+    raise "event handler is unknown: #{_event_type.inspect}" unless event_type
+
+    _disconnect_block = options[:disconnect]
+    raise ":disconnect handler must not accept any arguments" if _disconnect_block && _disconnect_block.arity != 1
+    disconnect_block = nil
+    if _disconnect_block
+      disconnect_inner_block = RMX.safe_block(_disconnect_block)
+      disconnect_block = lambda do |err|
+        disconnect_inner_block.call(err)
+      end.weak!
+    end
+    handler = nil
+    if and_then.arity == 1
+      inner_block = RMX.safe_block(lambda do |snap|
+        datasnap = RMXFirebaseDataSnapshot.new(snap)
+        completion.call(datasnap)
+      end)
+      wrapped_block = lambda do |snap|
+        inner_block.call(snap)
+      end.weak!
+      if disconnect_block
+        if options[:once]
+          RMXFirebase::INTERNAL_QUEUE.sync do
+            handler = observeSingleEventOfType(event_type, withBlock:wrapped_block, withCancelBlock:disconnect_block)
+          end
+        else
+          RMXFirebase::INTERNAL_QUEUE.sync do
+            handler = observeEventType(event_type, withBlock:wrapped_block, withCancelBlock:disconnect_block)
+          end
+        end
+      else
+        if options[:once]
+          RMXFirebase::INTERNAL_QUEUE.sync do
+            handler = observeSingleEventOfType(event_type, withBlock:wrapped_block)
+          end
+        else
+          RMXFirebase::INTERNAL_QUEUE.sync do
+            handler = observeEventType(event_type, withBlock:wrapped_block)
+          end
+        end
+      end
+    else
+      inner_block = RMX.safe_block(lambda do |snap, prev|
+        datasnap = RMXFirebaseDataSnapshot.new(snap)
+        completion.call(datasnap, prev)
+      end)
+      wrapped_block = lambda do |snap, prev|
+        inner_block.call(snap, prev)
+      end.weak!
+      if disconnect_block
+        if options[:once]
+          RMXFirebase::INTERNAL_QUEUE.sync do
+            handler = observeSingleEventOfType(event_type, andPreviousSiblingNameWithBlock:wrapped_block, withCancelBlock:disconnect_block)
+          end
+        else
+          RMXFirebase::INTERNAL_QUEUE.sync do
+            handler = observeEventType(event_type, andPreviousSiblingNameWithBlock:wrapped_block, withCancelBlock:disconnect_block)
+          end
+        end
+      else
+        if options[:once]
+          RMXFirebase::INTERNAL_QUEUE.sync do
+            handler = observeSingleEventOfType(event_type, andPreviousSiblingNameWithBlock:wrapped_block)
+          end
+        else
+          RMXFirebase::INTERNAL_QUEUE.sync do
+            handler = observeEventType(event_type, andPreviousSiblingNameWithBlock:wrapped_block)
+          end
+        end
+      end
+    end
+    unless options[:once]
+      @_outstanding_handlers ||= OutstandingHandlers.new(self)
+      @_outstanding_handlers << handler
+    end
+    handler
+  end
+
+  class OutstandingHandlers
+
+    RMX(self).weak_attr_accessor :scope
+
+    def initialize(_scope)
+      self.scope = _scope
+      @handlers = []
+    end
+
+    def <<(handler)
+      @handlers << handler
+    end
+
+    def handlers
+      @handlers
+    end
+
+    def off(handle=nil)
+      if s = scope
+        if _handle = @handlers.delete(handle)
+          # p s.rmx_object_desc, "remove handle", _handle
+          RMXFirebase::INTERNAL_QUEUE.sync do
+            s.removeObserverWithHandle(_handle)
+          end
+        else
+          _handlers = @handlers.dup
+          while _handlers.size > 0
+            _handle = _handlers.shift
+            off(_handle)
+          end
+        end
+      end
+    end
+
+    def dealloc
+      off
+      super
+    end
+  end
+
+  def once(event_type, options={}, &and_then)
+    on(event_type, options.merge(:once => true), &and_then)
+  end
+
+  def _off(handle)
+    if @_outstanding_handlers
+      @_outstanding_handlers.off(handle)
+    end
+    self
+  end
+
+  def off(handle)
+    RMXFirebase::QUEUE.barrier_async do
+      _off(handle)
+    end
+    self
+  end
+
+  def description
+    AFHTTPRequestSerializer.serializer.requestWithMethod("GET", URLString: "https://#{repo.repoInfo.host}#{path.toString}", parameters:queryParams.queryObject).URL.absoluteString
+  end
+
+end

data/lib/motion/Firebase+RMXFirebase.rb

@@ -0,0 +1,93 @@
+class Firebase
+
+  DEBUG_SETVALUE = RMX::Env['rmx_firebase_debug_setvalue'] == '1'
+
+  def rmx_object_desc
+    "#{super}:#{description}"
+  end
+
+  def [](*names)
+    if names.length == 0
+      childByAutoId
+    else
+      childByAppendingPath(names.join('/'))
+    end
+  end
+
+  def limited(limit)
+    queryLimitedToNumberOfChildren(limit)
+  end
+
+  def starting_at(priority)
+    queryStartingAtPriority(priority)
+  end
+
+  def ending_at(priority)
+    queryEndingAtPriority(priority)
+  end
+
+  def rmx_arrayToHash(array)
+    hash = {}
+    array.each_with_index do |item, i|
+      hash[i.to_s] = item
+    end
+    hash
+  end
+
+  def rmx_castValue(value, key=nil)
+    if value == true
+    elsif value == false
+    elsif value.is_a?(NSString)
+    elsif value.is_a?(NSNumber)
+    elsif value.nil?
+      p "FIREBASE_BAD_TYPE FIXED NIL: #{File.join(*[ description, key ].compact.map(&:to_s))}", "!"
+      value = {}
+    elsif value.is_a?(Array)
+      value = rmx_arrayToHash(value)
+      p "FIREBASE_BAD_TYPE FIXED ARRAY: #{File.join(*[ description, key ].compact.map(&:to_s))}: #{value.inspect} (type: #{value.className.to_s})", "!"
+    elsif value.is_a?(NSDictionary)
+      _value = value.dup
+      new_value = {}
+      _value.keys.each do |k|
+        new_value[k.to_s] = rmx_castValue(_value[k], k)
+      end
+      value = new_value
+    else
+      p "FIREBASE_BAD_TYPE FATAL: #{File.join(*[ description, key ].compact.map(&:to_s))}: #{value.inspect} (type: #{value.className.to_s})", "!"
+    end
+    # always return the value, corrected or not
+    value
+  end
+
+  def rmx_setValue(value, andPriority:priority)
+    # value = rmx_castValue(value)
+    setValue(value, andPriority:priority)
+  end
+  def rmx_setValue(value)
+    # value = rmx_castValue(value)
+    setValue(value)
+  end
+  def rmx_onDisconnectSetValue(value)
+    value = rmx_castValue(value)
+    onDisconnectSetValue(value)
+  end
+
+  alias_method 'orig_setValue', 'setValue'
+  alias_method 'orig_setValueAndPriority', 'setValue:andPriority'
+
+  def setValue(value, andPriority:priority)
+    if DEBUG_SETVALUE
+      p description, "setValue:andPriority", value, priority
+    end
+    value = rmx_castValue(value)
+    orig_setValueAndPriority(value, priority)
+  end
+  def setValue(value)
+    if DEBUG_SETVALUE
+      p description, "setValue:", value
+    end
+    value = rmx_castValue(value)
+    orig_setValue(value)
+  end
+
+end

data/lib/motion/RMXFirebase.rb

@@ -0,0 +1,31 @@
+module RMXFirebase
+
+  QUEUE = Dispatch::Queue.new("RMXFirebase")
+  INTERNAL_QUEUE = Dispatch::Queue.new("RMXFirebase.internal")
+
+  DEBUG_IDENTITY_MAP = RMX::Env['rmx_firebase_debug_identity_map'] == '1'
+  DEBUG_MODEL_DEALLOC = RMX::Env['rmx_firebase_debug_model_dealloc'] == '1'
+
+  def self.queue_for(queueish)
+    if queueish == :main || queueish.nil?
+      Dispatch::Queue.main
+    elsif queueish == :async
+      QUEUE
+    else
+      queueish
+    end
+  end
+
+  def self.block_on_queue(queue, *args, &block)
+    queue = queue_for(queue)
+    if queue == Dispatch::Queue.main && NSThread.currentThread.isMainThread
+      block.call(*args)
+    else
+      queue.barrier_async do
+        block.call(*args)
+      end
+    end
+  end
+
+end
+Firebase.setDispatchQueue(RMXFirebase::INTERNAL_QUEUE.dispatch_object)

data/lib/motion/RMXFirebaseBatch.rb

@@ -0,0 +1,102 @@
+class RMXFirebaseBatch
+
+  include RMXCommonMethods
+
+  def self.new(*models)
+    _models = models.dup
+    _models = _models.flatten.compact
+    x = super()
+    RMXFirebase::QUEUE.barrier_async do
+      x.setup_models(_models)
+    end
+    x
+  end
+
+  def initialize
+    @models = []
+    @ready_models = []
+    @complete_blocks = {}
+  end
+
+  def setup_models(the_models)
+    RMX(self).require_queue!(RMXFirebase::QUEUE, __FILE__, __LINE__) if RMX::DEBUG_QUEUES
+    @ready = false
+    @models = the_models.dup
+    @ready_count = 0
+    @pending_count = @models.size
+    if @models.any?
+      _models = @models.dup
+      _pairs = []
+      i = 0
+      while _models.size > 0
+        ii = i # strange: proc doesnt seem to close over i correctly
+        model = _models.shift
+        blk = proc do
+          RMX(self).require_queue!(RMXFirebase::QUEUE, __FILE__, __LINE__) if RMX::DEBUG_QUEUES
+          # p "COMPLETE!", ii, model
+          @complete_blocks.delete(model)
+          @ready_models[ii] = model
+          @ready_count += 1
+          @pending_count -= 1
+          if @pending_count == 0
+            ready!
+          end
+        end
+        @complete_blocks[model] = blk
+        _pairs << [ model, blk ]
+        i += 1
+      end
+      RMXFirebase::QUEUE.barrier_async do
+        while pair = _pairs.shift
+          pair[0].once(RMXFirebase::QUEUE, &pair[1])
+        end
+      end
+    else
+      RMXFirebase::QUEUE.barrier_async do
+        ready!
+      end
+    end
+  end
+
+  def ready!
+    RMXFirebase::QUEUE.barrier_async do
+      @ready = true
+      # p "models", models.dup
+      # p "ready_models", ready_models.dup
+      RMX(self).trigger(:ready, @ready_models.dup)
+    end
+  end
+
+  def cancel!
+    RMXFirebase::QUEUE.barrier_async do
+      models_outstanding = @complete_blocks.keys.dup
+      while models_outstanding.size > 0
+        model = models_outstanding.shift
+        if blk = @complete_blocks[model]
+          @complete_blocks.delete(model)
+          model.cancel_block(&blk)
+        end
+      end
+    end
+  end
+
+  def ready?
+    !!@ready
+  end
+
+  def once(queue=nil, &block)
+    RMXFirebase::QUEUE.barrier_async do
+      if ready?
+        RMXFirebase.block_on_queue(queue, @ready_models.dup, &block)
+      else
+        RMX(self).once(:ready, :strong => true, :queue => queue, &block)
+      end
+    end
+    self
+  end
+
+  def cancel_block(&block)
+    RMX(self).off(:ready, &block)
+  end
+
+end