rm-extensions 0.0.1 → 0.0.2

data/lib/motion/rm-extensions.rb

@@ -3,6 +3,25 @@ module RMExtensions
   # this module is included on Object, so these methods are available from anywhere in your code.
   module ObjectExtensions
 
+    def rmext_weak_attr_accessor(*attrs)
+      attrs.each do |attr|
+        define_method(attr) do
+          if val = instance_variable_get("@#{attr}")
+            val.nonretainedObjectValue
+          end
+        end
+        define_method("#{attr}=") do |val|
+          if val.nil?
+            instance_variable_set("@#{attr}", nil)
+          else
+            # should we do an rmext_on_dealloc on the val?
+            instance_variable_set("@#{attr}", NSValue.valueWithNonretainedObject(val))
+          end
+          val
+        end
+      end
+    end
+
     def rmext_assert_main_thread!
       raise "This method must be called on the main thread." unless NSThread.currentThread.isMainThread
     end
@@ -71,6 +90,11 @@ module RMExtensions
       end
     end
 
+    # #rmext_context yields an object you can treat like an openstruct (the "context")
+    def rmext_context(&block)
+      ::RMExtensions::Context.create(self, &block)
+    end
+
     # #rmext_retained_context yields an object you can treat like an openstruct.  you can get/set any
     # property on it.  the context is globally retained, until #detach! is called on the context.
     # this convention should fill the gap where local variables and scope bugs currently occur in RM,
@@ -100,16 +124,90 @@ module RMExtensions
     #
     # experimental feature:
     #
-    # you can call #beginBackground! on the context, and it will check-out a background task identifier,
+    # you can call #begin_background! on the context, and it will check-out a background task identifier,
     # and automatically end the background task when you call #detach! as normal.
     def rmext_retained_context(&block)
-      ::RMExtensions::RetainedContext.retained(self, &block)
+      ::RMExtensions::RetainedContext.create(self, &block)
+    end
+
+
+    def rmext_observe(object, key, &block)
+      # p "+ rmext_observe", self, object, key
+      rmext_observe_passive(object, key, &block)
+      block.call(object.send(key)) unless block.nil?
+    end
+
+    def rmext_observe_passive(object, key, &block)
+      wop = ::RMExtensions::WeakObserverProxy.get(self)
+      b = -> (old_value, new_value) do
+        block.call(new_value) unless block.nil?
+      end
+      wop.observe(object, key, &b)
+    end
+
+    def rmext_unobserve(object, key)
+      wop = ::RMExtensions::WeakObserverProxy.get(self)
+      wop.unobserve(object, key)
+      wop.clear_empty_targets!
+    end
+
+    def rmext_unobserve_all
+      wop = ::RMExtensions::WeakObserverProxy.get(self)
+      wop.unobserve_all
+    end
+
+    def rmext_on_dealloc(&block)
+      internalObject = ::RMExtensions::OnDeallocInternalObject.create(&block)
+      internalObject.obj = self
+      @rmext_on_dealloc_blocks ||= {}
+      @rmext_on_dealloc_blocks[internalObject] = internalObject
+      nil
+    end
+
+    def rmext_cancel_on_dealloc(block)
+      @rmext_on_dealloc_blocks ||= {}
+      if internalObject = @rmext_on_dealloc_blocks[block]
+        internalObject.block = nil
+        @rmext_on_dealloc_blocks.delete(block)
+      end
+      nil
+    end
+
+  end
+
+end
+Object.send(:include, ::RMExtensions::ObjectExtensions)
+
+module RMExtensions
+  # You don't use these classes directly.
+  class Context
+
+    class << self
+      def create(origin, &block)
+        x = new
+        block.call(x) unless block.nil?
+        x
+      end
+    end
+
+    attr_accessor :hash
+
+    def initialize
+      self.hash = {}
+    end
+
+    def method_missing(method, *args)
+      m = method.to_s
+      if m =~ /(.+)?=$/
+        hash[$1] = args.first
+      else
+        hash[m]
+      end
     end
 
   end
 
-  # You don't use this class directly.
-  class RetainedContext
+  class RetainedContext < Context
 
     class << self
       def rmext_retains
@@ -122,31 +220,25 @@ module RMExtensions
         @rmext_retains_queue
       end
 
-      def retained(origin, &block)
+      def create(origin, &block)
         x = new
         x.hash["retained_origin"] = origin
         x.hash["retained_block"] = block
         x.rmext_retain!
-        block.call(x)
+        block.call(x) unless block.nil?
         x
       end
     end
 
-    attr_accessor :hash
-
-    def initialize
-      self.hash = {}
-    end
-
     # if you provide a block, you are responsible for calling #detach!,
     # otherwise, the expiration handler will just call #detach!
-    def beginBackground!(&block)
+    def begin_background!(&block)
       hash["bgTaskExpirationHandler"] = block
       hash["bgTask"] = UIApplication.sharedApplication.beginBackgroundTaskWithExpirationHandler(-> do
         if hash["bgTaskExpirationHandler"]
           hash["bgTaskExpirationHandler"].call
         else
-          x.detach!
+          detach!
         end
       end)
     end
@@ -159,19 +251,85 @@ module RMExtensions
       rmext_detach!
     end
 
+    def detach_on_death_of(object)
+      object.rmext_on_dealloc(&detach_death_proc)
+    end
+
+    def detach_death_proc
+      proc { |x| detach! }
+    end
+
     def method_missing(method, *args)
       unless hash
         raise "You detached this rmext_retained_context and then called: #{method}"
       end
-      m = method.to_s
-      if m =~ /(.+)?=$/
-        hash[$1] = args.first
-      else
-        hash[m]
+      super
+    end
+
+  end
+
+  class WeakObserverProxy
+    include BW::KVO
+    rmext_weak_attr_accessor :obj
+    attr_accessor :strong_object_id, :strong_class_name
+    def initialize(strong_object)
+      self.obj = strong_object
+      self.strong_object_id = strong_object.object_id
+      self.strong_class_name = strong_object.class.name
+      self.class.weak_observer_map[strong_object_id] = self
+      strong_object.rmext_on_dealloc(&kill_observation_proc)
+    end
+    # isolate this in its own method so it wont create a retain cycle
+    def kill_observation_proc
+      proc { |x|
+        # uncomment to verify deallocation is working.  if not, there is probably
+        # a retain cycle somewhere in your code.
+        # p "kill_observation_proc", self
+        self.obj = nil
+        unobserve_all
+        self.class.weak_observer_map.delete(strong_object_id)
+      }
+    end
+    def clear_empty_targets!
+      return if @targets.nil?
+      @targets.each_pair do |target, key_paths|
+        if !key_paths || key_paths.size == 0
+          @targets.delete(target)
+        end
       end
+      nil
+    end
+    def inspect
+      "#{strong_class_name}:#{strong_object_id}"
+    end
+    def targets
+      @targets
+    end
+    def self.weak_observer_map
+      Dispatch.once { $weak_observer_map = {} }
+      $weak_observer_map
+    end
+    def self.get(obj)
+      return obj if obj.is_a?(WeakObserverProxy)
+      weak_observer_map[obj.object_id] || new(obj)
     end
+  end
 
+  class OnDeallocInternalObject
+    attr_accessor :block
+    rmext_weak_attr_accessor :obj
+    def self.create(&block)
+      x = new
+      x.block = block
+      x
+    end
+    def dealloc
+      if block
+        block.call(obj)
+        self.block = nil
+      end
+      super
+    end
   end
 
 end
-Object.send(:include, ::RMExtensions::ObjectExtensions)

data/lib/rm-extensions/version.rb

@@ -1,3 +1,3 @@
 module RMExtensions
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/rm-extensions.gemspec

@@ -16,4 +16,5 @@ Gem::Specification.new do |gem|
   gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
   gem.require_paths = ["lib"]
+  gem.add_dependency('bubble-wrap', '>= 1.1.5')
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rm-extensions
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,8 +9,24 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-04-19 00:00:00.000000000 Z
-dependencies: []
+date: 2013-05-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bubble-wrap
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.1.5
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.1.5
 description: Extensions and helpers for dealing with various areas of rubymotion
 email:
 - joenoon@gmail.com