rm-extensions 0.3.3 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4638058073ecd449cd49a4ae5d0b2c0bcea20304
-  data.tar.gz: fda67c1392046c93f1c7de0c6de830cf68cd733b
+  metadata.gz: 2c40f86893d94e3fadea28f20067e25ca3931f26
+  data.tar.gz: b2758a852a8a0a9dd4e47763e6785e509f255bf3
 SHA512:
-  metadata.gz: d78724ff4f31f6014c7dc9732cc3a6a80919f3ccc38c0abc2668f51eb21c822b2eafb3e098488a7c12acbb2d708d6b33fca5662ad253c1034d9f34474052263d
-  data.tar.gz: ea9fb77064f3fb6904c8ec56ab0a50fac3f61b23d41dfeeec5d7ee4051442bb869b2c7a53664d0615dbdbe3f2aae6345cea99572b9f8cd4d8de92e16a34f0086
+  metadata.gz: 0d24baa54ceb6ce6b24806f1c9a3723a068c5679420b4328df3f9e5a71b09890e249948965442eabefd02f86ed2ac9f48b1477115a5aeff306d9649e3a80a410
+  data.tar.gz: 68224e36927975027038177209c43e4d5eb555e103f05f448cedc34510718019db59dbc0b3574664d0295ff7ee94331201ffe5b41b12eeedff86ff470ff20865

data/lib/motion/events.rb

@@ -0,0 +1,207 @@
+module RMExtensions
+
+  module ObjectExtensions
+
+    module Events
+
+      def rmext_events_proxy
+        @rmext_events_proxy ||= EventsProxy.new(self)
+      end
+
+      # register a callback when an event is triggered on this object.
+      def rmext_on(object, event, &block)
+        object.rmext_events_proxy.on(event, inContext:self, withBlock:block)
+      end
+
+      def rmext_now_and_on(object, event, &block)
+        object.rmext_events_proxy.now_and_on(event, inContext:self, withBlock:block)
+      end
+
+      # register a callback when an event is triggered on this object and remove it after it fires once
+      def rmext_once(object, event, &block)
+        object.rmext_events_proxy.once(event, inContext:self, withBlock:block)
+      end
+
+      # remove a specific callback for an event on object
+      def rmext_off(object, event, &block)
+        if object.rmext_events_proxy?
+          object.rmext_events_proxy.off(event, inContext:self, withBlock:block)
+        end
+      end
+
+      # remove all event callbacks on this object,
+      # remove all event callbacks from other objects in this object's "self"
+      def rmext_cleanup
+        if @rmext_events_proxy
+          @rmext_events_proxy.cleanup
+        end
+      end
+
+      ### these get called on the object: ie. @model.rmext_off_all
+
+      # remove all event callbacks on this object
+      def rmext_off_all
+        if @rmext_events_proxy
+          @rmext_events_proxy.off_all
+        end
+      end
+
+      # trigger an event with value on this object
+      def rmext_trigger(event, value=nil)
+        if @rmext_events_proxy
+          @rmext_events_proxy.trigger(event, value)
+        end
+      end
+
+    end
+
+  end
+
+  class EventResponse
+    attr_accessor :context, :value, :target, :event
+  end
+
+  # Proxy class used to hold the actual listeners and contexts where listening
+  # and watches for the real class intended to hold the observation to be
+  # deallocated, so the events can be cleaned up.
+  class EventsProxy
+
+    def initialize(obj)
+      @weak_object = WeakRef.new(obj)
+      @desc = obj.inspect
+      @events = NSMapTable.weakToStrongObjectsMapTable
+      @listenings = NSHashTable.weakObjectsHashTable
+      if ::RMExtensions.debug?
+        p "created EventsProxy(#{@desc})"
+      end
+    end
+
+    def dealloc
+      @did_dealloc = true
+      cleanup
+      if ::RMExtensions.debug?
+        p "dealloc EventsProxy(#{@desc})"
+      end
+      super
+    end
+
+    def cleanup
+      off_all
+      off_all_context
+      true
+    end
+
+    def on(event, inContext:context, withBlock:block)
+      return if event.nil? || block.nil?
+      event = event.to_s
+      context ||= self.class
+      unless context_events = @events.objectForKey(context)
+        context_events = {}
+        @events.setObject(context_events, forKey:context)
+      end
+      unless context_event_blocks = context_events.objectForKey(event)
+        context_event_blocks = []
+        context_events.setObject(context_event_blocks, forKey:event)
+      end
+      block.weak!
+      context_event_blocks.addObject block
+      # i.e.: controller/view listening_to model
+      context.rmext_events_proxy.listening_to(@weak_object)
+    end
+
+    def listening_to(object)
+      if ::RMExtensions.debug?
+        p "listening_to object", object.class, "from context", @weak_object.class
+      end
+      @listenings.addObject(object)
+    end
+
+    def now_and_on(event, inContext:context, withBlock:block)
+      rmext_inline_or_on_main_q do
+        res = EventResponse.new
+        res.context = context
+        res.value = nil
+        res.target = @weak_object
+        res.event = event
+        block.call(res)
+      end
+      on(event, inContext:context, withBlock:block)
+    end
+
+    def off(event, inContext:context, withBlock:block)
+      return if event.nil? || block.nil?
+      event = event.to_s
+      context ||= self.class
+      return unless context_events = @events.objectForKey(context)
+      return unless context_event_blocks = context_events.objectForKey(event)
+      context_event_blocks.removeObject block
+      nil
+    end
+
+    def once(event, inContext:context, withBlock:block)
+      block.weak!
+      once_block = lambda do |opts|
+        off(event, inContext:context, withBlock:once_block)
+        block.call(opts)
+      end
+      on(event, inContext:context, withBlock:once_block)
+    end
+
+    def off_all
+      @events.removeAllObjects
+    end
+
+    def off_context(context)
+      @events.setObject(nil, forKey:context)
+    end
+
+    def off_all_context
+      while object = @listenings.anyObject
+        if ::RMExtensions.debug?
+          p "remove object", object.class, "from context", @weak_object.class
+        end
+        @listenings.removeObject(object)
+        object.rmext_events_proxy.off_context(@weak_object)
+      end
+    end
+
+    def trigger(event, value)
+      # m_desc = nil
+      # if ::RMExtensions.debug?
+      #   m_desc = "~~> EventsProxy(#{@desc})#trigger(#{event}, #{value.inspect.split(" ").first }>)"
+      #   p "called", m_desc
+      # end
+      rmext_inline_or_on_main_q do
+        next if @did_dealloc
+        next if event.nil?
+        event = event.to_s
+        keyEnumerator = @events.keyEnumerator
+        contexts = []
+        while context = keyEnumerator.nextObject
+          contexts.push context
+        end
+        while context = contexts.pop
+          if context_events = @events.objectForKey(context)
+            if event_blocks = context_events[event]
+              blocks = [] + event_blocks
+              # if ::RMExtensions.debug?
+              #   p "blocks.size", blocks.size, m_desc
+              # end
+              while blk = blocks.pop
+                res = EventResponse.new
+                res.context = context
+                res.value = value
+                res.target = @weak_object
+                res.event = event
+                blk.call(res)
+              end
+            end
+          end
+        end
+      end
+      nil
+    end
+  end
+
+end
+Object.send(:include, ::RMExtensions::ObjectExtensions::Events)

data/lib/rm-extensions/version.rb

@@ -1,3 +1,3 @@
 module RMExtensions
-  VERSION = "0.3.3"
+  VERSION = "0.4.0"
 end

data/lib/rm-extensions.rb

@@ -9,7 +9,7 @@ Motion::Project::App.setup do |app|
     layout
     util
     accessors
-    observation
+    events
     queues
   ).reverse.each do |x|
     app.files.unshift(File.join(File.dirname(__FILE__), "motion/#{x}.rb"))

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rm-extensions
 version: !ruby/object:Gem::Version
-  version: 0.3.3
+  version: 0.4.0
 platform: ruby
 authors:
 - Joe Noon
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-01-16 00:00:00.000000000 Z
+date: 2014-01-19 00:00:00.000000000 Z
 dependencies: []
 description: Extensions and helpers for dealing with various areas of rubymotion
 email:
@@ -24,8 +24,8 @@ files:
 - Rakefile
 - app/app_delegate.rb
 - lib/motion/accessors.rb
+- lib/motion/events.rb
 - lib/motion/layout.rb
-- lib/motion/observation.rb
 - lib/motion/queues.rb
 - lib/motion/util.rb
 - lib/rm-extensions.rb

data/lib/motion/observation.rb

@@ -1,297 +0,0 @@
-module RMExtensions
-
-  module ObjectExtensions
-
-    module Observation
-
-      def rmext_observation_proxy
-        @rmext_observation_proxy ||= ObservationProxy.new(self)
-      end
-
-      def rmext_observe_passive(object, keyPath:key, withBlock:block)
-        rmext_observe(object, keyPath:key, options:(NSKeyValueObservingOptionNew | NSKeyValueObservingOptionOld), withBlock:block)
-      end
-
-      def rmext_observe(object, keyPath:key, withBlock:block)
-        rmext_observe(object, keyPath:key, options:(NSKeyValueObservingOptionNew | NSKeyValueObservingOptionOld | NSKeyValueObservingOptionInitial), withBlock:block)
-      end
-
-      def rmext_observe(object, keyPath:key, options:options, withBlock:block)
-        rmext_observation_proxy.observe(object, keyPath:key, options:options, withBlock:block)
-      end
-
-      # unobserve an existing observation
-      def rmext_unobserve(object, keyPath:key)
-        if @rmext_observation_proxy
-          @rmext_observation_proxy.unobserve(object, keyPath:key)
-        end
-      end
-
-      # unobserve all existing observations
-      def rmext_unobserve_all
-        if @rmext_observation_proxy
-          @rmext_observation_proxy.unobserve_all
-        end
-      end
-
-      # register a callback when an event is triggered on this object.
-      #
-      # `inContext` should be passed the object context that the block was originally
-      # created in.  if you are writing the block inline, this would be self.  if
-      # you have a more complicated situation where you are passing the block around as
-      # an argument from another scope or method, you should take care to also keep
-      # track of it's context, so you can pass it correctly here.
-      #
-      # the context is needed to properly manage memory and let the block "drop out"
-      # when it's context deallocates, instead of creating leaks.
-      #
-      def rmext_on(event, inContext:context, withBlock:block)
-        rmext_observation_proxy.on(event, inContext:context, withBlock:block)
-      end
-
-      # register a callback when an event is triggered on this object and remove it after it fires once
-      # see `#rmext_on` for notes about `inContext`
-      def rmext_once(event, inContext:context, withBlock:block)
-        rmext_observation_proxy.once(event, inContext:context, withBlock:block)
-      end
-
-      # remove a specific callback for an event on this object
-      # see `#rmext_on` for notes about `inContext`
-      def rmext_off(event, inContext:context, withBlock:block)
-        if @rmext_observation_proxy
-          @rmext_observation_proxy.off(event, inContext:context, withBlock:block)
-        end
-      end
-
-      # remove all event callbacks on this object
-      def rmext_off_all
-        if @rmext_observation_proxy
-          @rmext_observation_proxy.off_all
-        end
-      end
-
-      # trigger an event with value on this object
-      def rmext_trigger(event, value=nil)
-        if @rmext_observation_proxy
-          @rmext_observation_proxy.trigger(event, value)
-        end
-      end
-
-      # remove all observations and event callbacks on this object
-      def rmext_cleanup
-        if @rmext_observation_proxy
-          @rmext_observation_proxy.cleanup
-        end
-      end
-
-    end
-
-  end
-
-  class ObservationResponse
-    attr_accessor :context, :value, :old_value, :target, :key, :indexes, :kind
-  end
-
-  class EventResponse
-    attr_accessor :context, :value, :target, :event
-  end
-
-  # # Proxy class used to hold the actual observation and watches for the real
-  # # class intended to hold the observation to be deallocated, so the
-  # # observation can be cleaned up.
-  class ObservationProxy
-
-    def initialize(obj)
-      @weak_object = WeakRef.new(obj)
-      @desc = obj.inspect
-      @events = NSMapTable.weakToStrongObjectsMapTable
-      @targets = {}
-      if ::RMExtensions.debug?
-        p "created ObservationProxy(#{@desc})"
-      end
-    end
-
-    def dealloc
-      @did_dealloc = true
-      cleanup
-      if ::RMExtensions.debug?
-        p "dealloc ObservationProxy(#{@desc})"
-      end
-      super
-    end
-
-    def cleanup
-      unobserve_all
-      off_all
-      true
-    end
-
-    def observe(target, keyPath:key_path, options:options, withBlock:block)
-      already_registered = registered?(target, key_path)
-      add_observer_block(target, key_path, block)
-      target.addObserver(self, forKeyPath:key_path, options:options, context:nil) unless already_registered
-    end
-
-    def unobserve(target, keyPath:key_path)
-      return unless registered?(target, key_path)
-      target.removeObserver(self, forKeyPath:key_path)
-      remove_observer_block(target, key_path)
-    end
-
-    def remove_observer_block(target, key_path)
-      return if target.nil? || key_path.nil?
-      key_path = key_path.to_s
-      target_hash = @targets[target]
-      if !target_hash.nil? && target_hash.has_key?(key_path)
-        target_hash.delete(key_path)
-      end
-    end
-
-    def unobserve_all
-      keys = [] + @targets.keys
-      while target = keys.pop
-        target_hash = @targets[target]
-        paths = [] + target_hash.keys
-        while key_path = paths.pop
-          unobserve(target, keyPath:key_path)
-        end
-      end
-      @targets.removeAllObjects
-    end
-
-    def registered?(target, key_path)
-      !target.nil? && !@targets[target].nil? && @targets[target].has_key?(key_path.to_s)
-    end
-
-    def add_observer_block(target, key_path, block)
-      return if target.nil? || key_path.nil? || block.nil?
-      key_path = key_path.to_s
-      @targets[target] ||= {}
-      @targets[target][key_path] ||= []
-      block.weak!
-      @targets[target][key_path].addObject block
-    end
-
-    # NSKeyValueObserving Protocol
-
-    def observeValueForKeyPath(key_path, ofObject:target, change:change, context:context)
-      # m_desc = nil
-      # if ::RMExtensions.debug?
-      #   m_desc = "~~> ObservationProxy(#{@desc})#observeValueForKeyPath(#{key_path}, ofObject:#{target.inspect.split(" ").first}>, ...)"
-      #   p "called", m_desc
-      # end
-      action = proc do
-        next if @did_dealloc
-        next if target.nil?
-        key_paths = @targets[target]
-        next if key_paths.nil?
-        blocks = key_paths[key_path]
-        next if blocks.nil?
-        blocks = [] + blocks # get a new array that can be popped
-        # if ::RMExtensions.debug?
-        #   p "blocks.size", blocks.size, m_desc
-        # end
-        while blk = blocks.pop
-          res = ObservationResponse.new
-          res.context = @weak_object
-          res.value = change[NSKeyValueChangeNewKey]
-          res.old_value = change[NSKeyValueChangeOldKey]
-          res.target = target
-          res.key = key_path
-          res.indexes = change[NSKeyValueChangeIndexesKey]
-          res.kind = change[NSKeyValueChangeKindKey]
-          blk.call(res)
-        end
-      end
-      if NSThread.currentThread.isMainThread
-        # if ::RMExtensions.debug?
-        #   p "inline execution", m_desc
-        # end
-        action.call
-      else
-        # if ::RMExtensions.debug?
-        #   p "dispatch execution", m_desc
-        # end
-        rmext_on_main_q(&action)
-      end
-    end
-
-    def on(event, inContext:context, withBlock:block)
-      return if event.nil? || block.nil?
-      event = event.to_s
-      context ||= self.class
-      unless context_events = @events.objectForKey(context)
-        context_events = {}
-        @events.setObject(context_events, forKey:context)
-      end
-      unless context_event_blocks = context_events.objectForKey(event)
-        context_event_blocks = []
-        context_events.setObject(context_event_blocks, forKey:event)
-      end
-      block.weak!
-      context_event_blocks.addObject block
-    end
-
-    def off(event, inContext:context, withBlock:block)
-      return if event.nil? || block.nil?
-      event = event.to_s
-      context ||= self.class
-      return unless context_events = @events.objectForKey(context)
-      return unless context_event_blocks = context_events.objectForKey(event)
-      context_event_blocks.removeObject block
-      nil
-    end
-
-    def once(event, inContext:context, withBlock:block)
-      block.weak!
-      once_block = lambda do |opts|
-        off(event, inContext:context, withBlock:once_block)
-        block.call(opts)
-      end
-      on(event, inContext:context, withBlock:once_block)
-    end
-
-    def off_all
-      @events.removeAllObjects
-    end
-
-    def trigger(event, value)
-      # m_desc = nil
-      # if ::RMExtensions.debug?
-      #   m_desc = "~~> ObservationProxy(#{@desc})#trigger(#{event}, #{value.inspect.split(" ").first }>)"
-      #   p "called", m_desc
-      # end
-      rmext_on_main_q do
-        next if @did_dealloc
-        next if event.nil?
-        event = event.to_s
-        keyEnumerator = @events.keyEnumerator
-        contexts = []
-        while context = keyEnumerator.nextObject
-          contexts.push context
-        end
-        while context = contexts.pop
-          if context_events = @events.objectForKey(context)
-            if event_blocks = context_events[event]
-              blocks = [] + event_blocks
-              # if ::RMExtensions.debug?
-              #   p "blocks.size", blocks.size, m_desc
-              # end
-              while blk = blocks.pop
-                res = EventResponse.new
-                res.context = context
-                res.value = value
-                res.target = @weak_object
-                res.event = event
-                blk.call(res)
-              end
-            end
-          end
-        end
-      end
-      nil
-    end
-  end
-
-end
-Object.send(:include, ::RMExtensions::ObjectExtensions::Observation)