callbacks_attachable 0.3.4 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e8a6bd534e0b47cbf70e05f3a770eddbb1b53bdc
-  data.tar.gz: e76520e94fe00df151e178f4cf7e70e62b4c5504
+  metadata.gz: 7851ad52aa0e5f3e20f1b74669c7b055a83b3c07
+  data.tar.gz: 953968fa4f6af44dcbcff1c1c2451063cd3dcfa5
 SHA512:
-  metadata.gz: 602b260b5e575d4efcffea7a1a2ac098cacc37ccf7ec02209315aab7f925191d8972b2ffab95cbd49310a2313f12dedcc447ec5340b4348693997a201ce449e1
-  data.tar.gz: 848f86e423e5a8a235d30e6a21679e57e74df5f35ddee2904e041868c11d7905ebd12b20e5e95df4018cba39aae3e6c3c90027abe8d6cc22cafd3595f47955fa
+  metadata.gz: 718d264ba8b815bbe20b35f7c02af16684b71267a4cbf413f4979d62f1438039f8478a8775d92be830b22daa0692dc274d877372e6db50adbfdba34e79587bc3
+  data.tar.gz: 0b45a12da19188cb38cd0ec60b23b39b8274cee805437e9f7d9fa51bbd20ccefd0681f57f33361d1ac35d614376a7a4f35d579cecceb47017a6b5b2d76d6abc6

data/lib/callbacks_attachable/all_instances_callback.rb

@@ -0,0 +1,24 @@
+module CallbacksAttachable
+  class AllInstancesCallback
+    def initialize(klass, skip: 0, &callback)
+      @class = klass
+      @skip = skip
+      @callback = callback
+      @call_counts = {}
+    end
+
+    def call(*args, **opts)
+      if instance = opts[:instance]
+        call_for_instance(instance, *args)
+      else
+        ObjectSpace.each_object(@class).all?{ |inst| call_for_instance(inst, *args) }
+      end
+    end
+
+    def call_for_instance(instance, *args)
+      @call_counts[instance.__id__] = @call_counts[instance.__id__].to_i + 1
+      return true if @call_counts[instance.__id__] <= @skip
+      false != instance.instance_exec(*args, &@callback)
+    end
+  end
+end

data/lib/callbacks_attachable/callback_handler.rb

@@ -0,0 +1,49 @@
+module CallbacksAttachable
+  class CallbackHandler
+    def initialize(object, callback_class)
+      @object = object
+      @callback_class = callback_class
+    end
+
+    def on(event, skip: 0, &callback)
+      __callbacks__[event] ||= []
+      __callbacks__[event] << @callback_class.new(@object, skip: skip, &callback)
+      __callbacks__[event].last
+    end
+
+    def once_on(event, *opts, &callback)
+      callback_registry = self
+      registered_callback = on(event, *opts) do |*args|
+        callback_registry.off(event, registered_callback)
+        yield(*args)
+      end
+    end
+
+    def until_true_on(event, *opts, &callback)
+      callback_registry = self
+      registered_callback = on(event, *opts) do |*args|
+        yield(*args).tap do |result|
+          callback_registry.off(event, registered_callback) if result
+        end
+      end
+    end
+
+    def trigger(event, *args, **opts)
+      return true if __callbacks__[event].nil?
+
+      # dup the callback list so that removing callbacks while iterating does
+      # still call all callbacks during map.
+      __callbacks__[event].dup.all?{ |callback| callback.call(*args, **opts) }
+    end
+
+    def off(event, callback)
+      __callbacks__[event].delete(callback)
+    end
+
+    private
+
+    def __callbacks__
+      @__callbacks__ ||= {}
+    end
+  end
+end

data/lib/callbacks_attachable/instance_callback.rb

@@ -0,0 +1,16 @@
+module CallbacksAttachable
+  class InstanceCallback
+    def initialize(instance, skip: 0, &callback)
+      @instance = instance
+      @skip = skip
+      @callback = callback
+      @call_count = 0
+    end
+
+    def call(*args, **opts)
+      @call_count += 1
+      return true if @call_count <= @skip
+      @callback.call(*args) != false
+    end
+  end
+end

data/lib/callbacks_attachable/version.rb

@@ -1,3 +1,3 @@
 module CallbacksAttachable
-  VERSION = "0.3.4"
+  VERSION = "1.0.0"
 end

data/lib/callbacks_attachable.rb

@@ -1,95 +1,65 @@
 require "callbacks_attachable/version"
+require "callbacks_attachable/callback_handler"
+require "callbacks_attachable/instance_callback"
+require "callbacks_attachable/all_instances_callback"
 
 module CallbacksAttachable
-  def self.included(base)
-    base.extend ClassMethods
+  def self.included(klass)
+    klass.extend ClassMethods
   end
 
   module ClassMethods
-    def on(event, skip: 0, &callback)
-      count = 0
-      callbacks[event] ||= []
-      callbacks[event] << proc do |*args|
-        next unless (count += 1) > skip
-        instance_exec(*args, &callback)
-      end
-      callbacks[event].last
+    def on(*args, &block)
+      __callback_handler__.on(*args, &block)
     end
 
-    def once_on(event, *opts, &callback)
-      klass = self
-      registered_callback = on(event, *opts) do |*args|
-        klass.off(event, registered_callback)
-        instance_exec(*args, &callback)
-      end
+    def once_on(*args, &block)
+      __callback_handler__.once_on(*args, &block)
     end
 
-    def until_true_on(event, *opts, &callback)
-      klass = self
-      registered_callback = on(event, *opts) do |*args|
-        instance_exec(*args, &callback).tap do |result|
-          klass.off(event, registered_callback) if result
-        end
-      end
+    def until_true_on(*args, &block)
+      __callback_handler__.until_true_on(*args, &block)
     end
 
-    def trigger(event, *args, context: self)
-      return true unless callbacks[event]
-
-      # dup the callback list so that removing callbacks while iterating does
-      # still call all callbacks during map.
-      callbacks[event].dup.all? do |callback|
-        context.instance_exec(*args, &callback) != false
-      end
+    def off(*args)
+      __callback_handler__.off(*args)
     end
 
-    def off(event, callback)
-      if callbacks[event]
-        callbacks[event].delete(callback)
-        callbacks.delete(event) if callbacks[event].empty?
-      end
-      true
+    def trigger(*args)
+      __callback_handler__.trigger(*args)
     end
 
     private
 
-    def callbacks
-      @callbacks ||= {}
+    def __callback_handler__
+      @__callback_handler__ ||= CallbackHandler.new(self, AllInstancesCallback)
     end
   end
 
   def on(*args, &block)
-    if_self(:on, *args, &block)
+    __callback_handler__.on(*args, &block)
   end
 
   def once_on(*args, &block)
-    if_self(:until_true_on, *args) do |*args|
-      block.call(*args)
-      true
-    end
+    __callback_handler__.once_on(*args, &block)
   end
 
   def until_true_on(*args, &block)
-    if_self(:until_true_on, *args, &block)
+    __callback_handler__.until_true_on(*args, &block)
   end
 
-  def trigger(event, *args)
-    self.class.trigger(event, *args, context: self)
+  def off(*args)
+    __callback_handler__.off(*args)
   end
 
-  def off(*args)
-    self.class.off(*args)
+  def trigger(*args)
+    self.class.trigger(*args, instance: self)
+    __callback_handler__.trigger(*args)
   end
 
   private
 
-  def if_self(*args, skip: 0, &block)
-    instance = self
-    count = 0
-    self.class.__send__(*args, skip: 0) do |*args|
-      next if instance != self
-      next unless (count += 1) > skip
-      block.call(*args)
-    end
+  def __callback_handler__
+    @__callback_handler__ ||= CallbackHandler.new(self, InstanceCallback)
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: callbacks_attachable
 version: !ruby/object:Gem::Version
-  version: 0.3.4
+  version: 1.0.0
 platform: ruby
 authors:
 - Christopher Aue
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-01-12 00:00:00.000000000 Z
+date: 2016-03-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -95,6 +95,9 @@ files:
 - Rakefile
 - callbacks_attachable.gemspec
 - lib/callbacks_attachable.rb
+- lib/callbacks_attachable/all_instances_callback.rb
+- lib/callbacks_attachable/callback_handler.rb
+- lib/callbacks_attachable/instance_callback.rb
 - lib/callbacks_attachable/version.rb
 homepage: https://github.com/christopheraue/ruby-callbacks_attachable
 licenses: