rm-extensions 0.4.5 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 79fc90e02999956244b32c6716f3ef47c6c40dce
-  data.tar.gz: 7afd5219125217fe0fe730b8c9ed629ef3dacc91
+  metadata.gz: 5508660ca09f24056f99da66f92638543dd64bbb
+  data.tar.gz: 4d03e2678ca57e1906faf277637ede4029d677b1
 SHA512:
-  metadata.gz: 4972527b0fcb5f5148c1a134e32cec2d458bb2f3c7db95ef83124f3f2bb3c49560b440735b0e5e568b3bbe017dc83431b6a38fee9fd3d52b543c89fc18bb8c94
-  data.tar.gz: c2a1c7fb7cc86cd69eb1bf9d4c8275234d3c2c1d9462a74cffbf1badd342daf42631c72ca5189368de738523756cd1e9498a46dc798a49220dbf574d8642c6f8
+  metadata.gz: 36069726b1441e036f165666810d61e9a6c1e1df5c8ac16e1ca9ead8d00ec8a7beca81f3d5b2ee22201654155e82842ed91ebb4b1ce8892ca67d386f621f44fa
+  data.tar.gz: 264354fcf310ccca5b4b7f729b1a1f79fe3b90ea9145ebdf195c7fea8381def8619acfde5fad8a25be4f1c125b1e7093985b1eedb32a9f6de2236b9182e192f6

data/lib/motion/accessors.rb

@@ -19,6 +19,26 @@ module RMExtensions
         end
       end
 
+      # creates an +attr_accessor+ like behavior, but the objects are
+      # stored in an NSMapTable with strong keys (the attrs) and
+      # weak values.  If the value deallocates, it becomes nil, unlike
+      # a traditional WeakRef.
+      # does not conform to KVO like attr_accessor does.
+      def rmext_zeroing_weak_attr_accessor(*attrs)
+        attrs.each do |attr|
+          define_method(attr) do
+            if @__zeroing_weak_holders
+              @__zeroing_weak_holders.objectForKey(attr)
+            end
+          end
+          define_method("#{attr}=") do |val|
+            @__zeroing_weak_holders ||= NSMapTable.strongToWeakObjectsMapTable
+            @__zeroing_weak_holders.setObject(val, forKey:attr)
+            val
+          end
+        end
+      end
+
     end
 
   end

data/lib/motion/events.rb

@@ -4,56 +4,59 @@ module RMExtensions
 
     module Events
 
-      def rmext_events_proxy
-        @rmext_events_proxy ||= EventsProxy.new(self)
+      def rmext_events_from_proxy
+        @rmext_events_from_proxy ||= EventsFromProxy.new(self)
       end
 
-      def rmext_events_proxy?
-        !@rmext_events_proxy.nil?
+      def rmext_events_from_proxy?
+        !!@rmext_events_from_proxy
       end
 
-      # register a callback when an event is triggered on this object.
-      def rmext_on(object, event, &block)
-        object.rmext_events_proxy.on(event, limit:-1, inContext:self, withBlock:block)
+      def rmext_events_to_proxy
+        @rmext_events_to_proxy ||= EventsToProxy.new(self)
       end
 
-      def rmext_now_and_on(object, event, &block)
-        object.rmext_events_proxy.now_and_on(event, inContext:self, withBlock:block)
+      def rmext_events_to_proxy?
+        !!@rmext_events_to_proxy
       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.on(event, limit:1, inContext:self, withBlock:block)
+      # register a callback when an event is triggered on this object.
+      def rmext_on(event, opts={}, &block)
+        rmext_events_from_proxy.on(event, opts, &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
+      def rmext_now_and_on(event, opts={}, &block)
+        rmext_events_from_proxy.now_and_on(event, opts, &block)
       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
+      # register a callback when an event is triggered on this object and remove it after it fires once
+      def rmext_once(event, opts={}, &block)
+        opts[:limit] = 1
+        rmext_events_from_proxy.on(event, opts, &block)
+      end
+
+      # @model.rmext_off(:fire, self)      # remove :fire in context "self"
+      # @model.rmext_off(:fire, &block)    # remove :fire for specific handler
+      # @model.rmext_off(:fire)            # remove all :fire in all knowns contexts
+      # @model.rmext_off(self)             # remove all events in context "self"
+      # @model.rmext_off                   # remove all events in all known contexts
+      def rmext_off(event=nil, context=nil, &block)
+        if rmext_events_from_proxy?
+          rmext_events_from_proxy.off(event, context, &block)
         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
+      # remove all event callbacks from other objects in this object's "self"
+      def rmext_cleanup
+        if rmext_events_to_proxy?
+          rmext_events_to_proxy.cleanup
         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)
+        if rmext_events_from_proxy?
+          rmext_events_from_proxy.trigger(event, value)
         end
       end
 
@@ -65,39 +68,80 @@ module RMExtensions
     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
+  # Proxy object used to hold the firing objects that this real object's
+  # "self" owns handlers for.
+  # Can be used to cleanup all handlers across all firing objects that have
+  # the hanlder's owner (Proc#owner) == this real object.
+  # Does not need to perform deallocation logic as nothing is retained
+  # and the real object will fall out of the cooresponding EventsFromProxy
+  # automatically.
+  class EventsToProxy
+
+    rmext_zeroing_weak_attr_accessor :weak_object
+    
+    def initialize(obj)
+      self.weak_object = obj
+      @has_handlers_for = NSHashTable.weakObjectsHashTable
+    end
+
+    def has_handlers_for!(firing_object)
+      if ::RMExtensions.debug?
+        p "CONTEXT:", weak_object.rmext_object_desc, "LISTENING TO:", firing_object.rmext_object_desc
+      end
+      @has_handlers_for.addObject(firing_object)
+    end
+
+    def cleanup(firing_object=nil)
+      # p "cleanup caller", caller
+      if firing_object
+        if @has_handlers_for.containsObject(firing_object)
+          if ::RMExtensions.debug?
+            p "CONTEXT:", weak_object.rmext_object_desc, "UNLISTENING TO:", firing_object.rmext_object_desc
+          end
+          @has_handlers_for.removeObject(firing_object)
+          firing_object.rmext_off(weak_object)
+        end
+      else
+        while firing_object = @has_handlers_for.anyObject
+          if ::RMExtensions.debug?
+            p "CONTEXT:", weak_object.rmext_object_desc, "UNLISTENING TO:", firing_object.rmext_object_desc
+          end
+          @has_handlers_for.removeObject(firing_object)
+          firing_object.rmext_off(weak_object)
+        end
+      end
+      true
+    end
+
+  end
+
+  # Proxy class used to hold the actual handlers and contexts of handlers.
+  # When the real class deallocates, all handlers are removed.
+  class EventsFromProxy
+
+    rmext_zeroing_weak_attr_accessor :weak_object
 
     def initialize(obj)
-      @weak_object = WeakRef.new(obj)
+      self.weak_object = obj
       @events = NSMapTable.weakToStrongObjectsMapTable
-      @listenings = NSHashTable.weakObjectsHashTable
       if ::RMExtensions.debug?
-        p "CREATED EventsProxy: #{@weak_object.rmext_object_desc}"
+        p "CREATED #{className}: #{weak_object.rmext_object_desc}"
       end
     end
 
     def dealloc
-      @did_dealloc = true
-      cleanup
+      # @did_dealloc = true
+      off
       if ::RMExtensions.debug?
-        p "DEALLOC EventsProxy: #{@weak_object.rmext_object_desc}"
+        p "DEALLOC #{className}: #{weak_object.rmext_object_desc}"
       end
       super
     end
 
-    def cleanup
-      off_all
-      off_all_context
-      true
-    end
-
-    def on(event, limit:limit, inContext:context, withBlock:block)
+    def on(event, opts={}, &block)
       return if event.nil? || block.nil?
       event = event.to_s
-      context ||= self.class
+      context = block.owner
       unless context_events = @events.objectForKey(context)
         context_events = {}
         @events.setObject(context_events, forKey:context)
@@ -107,64 +151,66 @@ module RMExtensions
         context_events.setObject(context_event_blocks, forKey:event)
       end
       block.weak!
-      context_event_blocks[block] = limit
-      # i.e.: controller/view listening_to model
-      context.rmext_events_proxy.listening_to(@weak_object)
-    end
-
-    # this is called in the reverse direction than normal
-    def listening_to(object)
-      if ::RMExtensions.debug?
-        p "CONTEXT:", @weak_object.rmext_object_desc, "LISTENING TO:", object.rmext_object_desc
-      end
-      @listenings.addObject(object)
+      context_event_blocks[block] = opts[:limit] || -1
+      # i.e.: controller/view has handlers for object
+      context.rmext_events_to_proxy.has_handlers_for!(weak_object)
     end
 
-    def now_and_on(event, inContext:context, withBlock:block)
+    def now_and_on(event, opts={}, &block)
       rmext_inline_or_on_main_q do
         res = EventResponse.new
-        res.context = context
+        res.context = block.owner
         res.value = nil
-        res.target = @weak_object
+        res.target = weak_object
         res.event = event
         block.call(res)
       end
-      on(event, limit:-1, 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.delete block
-      nil
-    end
-
-    def off_all
-      @events.removeAllObjects
+      on(event, opts, &block)
     end
 
-    def off_context(context)
-      @events.setObject(nil, forKey:context)
-    end
-
-    def off_all_context
-      while object = @listenings.anyObject
-        if ::RMExtensions.debug?
-          p "CONTEXT:", @weak_object.rmext_object_desc, "UNLISTENING TO:", object.rmext_object_desc
-        end
-        @listenings.removeObject(object)
-        if object.rmext_events_proxy?
-          object.rmext_events_proxy.off_context(@weak_object)
+    def off(event=nil, context=nil, &block)
+      if event.is_a?(String) || event.is_a?(Symbol)
+        event = event.to_s
+        if context
+          # remove all handlers for the given event in the given context
+          if context_events = @events.objectForKey(context)
+            context_events.delete(event)
+          end
+        elsif block
+          # remove the one block for the event in the blocks #owner
+          context = block.owner
+          if context_events = @events.objectForKey(context)
+            if context_event_blocks = context_events.objectForKey(event)
+              context_event_blocks.delete block
+            end
+          end
+        else
+          # remove all handlers for the event in all contexts known
+          keyEnumerator = @events.keyEnumerator
+          contexts = []
+          while context = keyEnumerator.nextObject
+            contexts.push context
+          end
+          while context = contexts.pop
+            if context_events = @events.objectForKey(context)
+              context_events.delete event
+            end
+          end
         end
+      elsif event
+        # event is really a context. remove all events and handlers for the context
+        context = event
+        @events.removeObjectForKey(context)
+      else
+        # remove everything
+        @events.removeAllObjects
       end
+      nil
     end
 
     def trigger(event, value)
       rmext_inline_or_on_main_q do
-        next if @did_dealloc
+        # next if @did_dealloc
         next if event.nil?
         event = event.to_s
         keyEnumerator = @events.keyEnumerator
@@ -177,24 +223,24 @@ module RMExtensions
             if event_blocks = context_events[event]
               blocks = event_blocks.keys
               if ::RMExtensions.debug?
-                p "TRIGGER:", event, "OBJECT:", @weak_object.rmext_object_desc, "CONTEXT:", context.rmext_object_desc, "BLOCKS SIZE:", blocks.size
+                p "TRIGGER:", event, "OBJECT:", weak_object.rmext_object_desc, "CONTEXT:", context.rmext_object_desc, "BLOCKS SIZE:", blocks.size
               end
               while block = blocks.pop
                 limit = event_blocks[block]
                 res = EventResponse.new
                 res.context = context
                 res.value = value
-                res.target = @weak_object
+                res.target = weak_object
                 res.event = event
                 block.call(res)
                 if limit == 1
                   # off
                   if ::RMExtensions.debug?
-                    p "LIMIT REACHED:", event, "OBJECT:", @weak_object.rmext_object_desc, "CONTEXT:", context.rmext_object_desc
+                    p "LIMIT REACHED:", event, "OBJECT:", weak_object.rmext_object_desc, "CONTEXT:", context.rmext_object_desc
                   end
-                  off(event, inContext:context, withBlock:block)
+                  off(event, context, &block)
                 elsif limit > 1
-                  context_events[block] -= 1
+                  event_blocks[block] -= 1
                 end
               end
             end

data/lib/motion/util.rb

@@ -34,7 +34,7 @@ module RMExtensions
         if ::RMExtensions::LongTask.outstanding_tasks.size.zero?
           rmext_block_on_main_q(block)
         else
-          rmext_once(::RMExtensions::LongTask, :all_complete) do |opts|
+          ::RMExtensions::LongTask.rmext_once(:all_complete) do |opts|
             block.call
           end
         end
@@ -115,7 +115,7 @@ module RMExtensions
       if @tracking
         ::RMExtensions::LongTask.outstanding_queue.sync do
           ::RMExtensions::LongTask.outstanding_tasks.delete(self)
-          ::RMExtensions::LongTask.internal do |internal_task|
+          ::RMExtensions::LongTask.internal("check for all complete") do |internal_task|
             rmext_on_main_q do
               if ::RMExtensions::LongTask.outstanding_tasks.size.zero?
                 ::RMExtensions::LongTask.rmext_trigger(:all_complete)

data/lib/rm-extensions/version.rb

@@ -1,3 +1,3 @@
 module RMExtensions
-  VERSION = "0.4.5"
+  VERSION = "0.5.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rm-extensions
 version: !ruby/object:Gem::Version
-  version: 0.4.5
+  version: 0.5.0
 platform: ruby
 authors:
 - Joe Noon
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-01-26 00:00:00.000000000 Z
+date: 2014-01-28 00:00:00.000000000 Z
 dependencies: []
 description: Extensions and helpers for dealing with various areas of rubymotion
 email: