callbacks_attachable 1.0.3 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 841ea199caa6811569cc442f4bb49848cae85667
-  data.tar.gz: 559a012545ba5b1721f0c603ff6abceda05920a7
+  metadata.gz: 2585bc2a52a1a090b2d8792ce16a1b2b674769d9
+  data.tar.gz: b9212eaecc4af017f087bdbc17e0083c1678e048
 SHA512:
-  metadata.gz: 0446b729f4bebdff0e3b2c2c304dcc1c54a83807e59c296ed4eb7623fb4e31328a3c94d091154dd8f755618e1846fc98c5024cdfb079d53fd61b039234d7b718
-  data.tar.gz: eed08c3f04df0b8a8c0908d5da139b6fdfaf814201dfbdd4bb2a481002e78be1c561cb8bdcd73f9d6a4028f9b84db07025f29b8c257709006aebb9674faaabd6
+  metadata.gz: 68601c07625b6fb386431b10bab77bae900a91d813aba44b50e7755a9c803e157cfd124d319d0dd133852a547ab3deaccd3e28bff38722a625c0d981329cf70c
+  data.tar.gz: 5caa67e516872ba4e4a46bacf92c77d954193517a4d5d062b59a05cbd2e230cc7e4603f1001a5e820470d8473b207c8b67dc56248dd15296850285add0890494

data/LICENSE.txt

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2015 Christopher Aue
+Copyright (c) 2015, 2016 Christopher Aue
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/README.md

@@ -1,8 +1,8 @@
 # CallbacksAttachable
 
-Attach callbacks to every ruby object including this mixin. Trigger all
-callbacks attached under the same namespace and detach callback when you no
-longer need them.
+Attach callbacks to a class and trigger them for all its instances or just one
+particular instance. Additionally, instances can also have their own set of
+individual callbacks.
 
 ## Installation
 
@@ -25,57 +25,54 @@ Or install it yourself as:
 ```ruby
 require 'callbacks_attachable'
 
-class CallbacksHolder
+class AClass
     include CallbacksAttachable
 end
 ```
 
 ### Callbacks attached to the class
 
-Attach callbacks to the class:
+Attach callbacks for an event to the class with:
 
 ```ruby
-callback = CallbacksHolder.on(:event) do |method|
+callback = AClass.on(:event) do |method|
     puts self.__send__(method)
 end
 ```
 
-Callbacks attached to the class are executed in the context of it, i.e. `self`
-points to the class.
-
-Trigger all `:event` callbacks with:
+Callbacks attached to a class are executed in the context of each existing
+instance. To trigger all `:event` callbacks for all instances of `AClass`, use:
 
 ```ruby
-CallbacksHolder.trigger(:event, :name) # => puts 'CallbacksHolder'
+AClass.trigger(:event, :name) # => puts 'AClass'
 ```
 
-The second and further arguments given to `.trigger` are passed down to the
-callback.
+The second and other arguments given to `.trigger` are passed to the callback.
 
-Callbacks can be executed in the context of a different context by passing the
-`context` option to `.trigger`:
+Callbacks attached to a class can also be triggered for just one of its
+instances with `.trigger_for`:
 
 ```ruby
-object = Object.new
-CallbacksHolder.trigger(:event, :__id__, context: object)
-# => puts the result of object.__id__
+an_instance = AClass.new
+AClass.trigger_for(an_instance, :event, :__id__)
+# => puts the result of an_instance.__id__
 ```
 
-To detach a callback call `.off` with the event namespace and the callback
-handle returned by `.on`:
+To detach a callback call `.off` with the event's name and the callback handle
+returned by `.on`:
 
 ```ruby
-CallbacksHolder.off(:event, callback)
-CallbacksHolder.trigger(:event, :name)  # => nothing will happen
+callback = AClass.on(:event) { do_something }
+AClass.off(:event, callback)
 ```
 
 If you want to execute a callback just a single time attach it with `.once_on`:
 
 ```ruby
-CallbacksHolder.once_on(:singularity) { puts 'callback called!' }
-CallbacksHolder.trigger(:singularity) # => puts 'callback called!' and immediately
+AClass.once_on(:singularity) { puts 'callback called!' }
+AClass.trigger(:singularity) # => puts 'callback called!' and immediately
                                       #    detaches the callback
-CallbacksHolder.trigger(:singularity) # => does nothing
+AClass.trigger(:singularity) # => does nothing
 ```
 
 To detach a callback when a condition is met use `.until_true_on`. The callback
@@ -83,43 +80,42 @@ will be detached if it has a truthy (!) return value.
 
 ```ruby
 counter = 0
-CallbacksHolder.until_true_on(:count_to_two) do
+AClass.until_true_on(:count_to_two) do
     puts counter
     counter >= 2
 end
 
-CallbacksHolder.trigger(:count_to_two) # => puts 0
-CallbacksHolder.trigger(:count_to_two) # => puts 1
-CallbacksHolder.trigger(:count_to_two) # => puts 2 and detaches the callback
-CallbacksHolder.trigger(:count_to_two) # => does nothing
+AClass.trigger(:count_to_two) # => puts 0
+AClass.trigger(:count_to_two) # => puts 1
+AClass.trigger(:count_to_two) # => puts 2 and detaches the callback
+AClass.trigger(:count_to_two) # => does nothing
 ```
 
 ### Callbacks attached to an instance
 
 All above mentioned methods on the class level also exist for each instance of
-the class. Callbacks are executed if the instance they are attached to or their
-class calls `#trigger`.
+the class. Callbacks for an individual instance are executed by calling
+`#trigger` on it. They are also called, when calling `.trigger` or
+`.trigger_for(instance, ...)` on its class.
 
-Callbacks are called in their lexical scope. So, `self` inside and outside
-the callback is the same object. The context of a callback cannot be changed
-with the `context` option of the `#trigger` method as it is possible for
-class callbacks.
+Callbacks attached to individual instances are evaluated in their lexical scope.
+So, `self` inside and outside the callback is the same object.
 
 ```ruby
-callbacks_holder1 = CallbacksHolder.new
-callbacks_holder2 = CallbacksHolder.new
+an_instance1 = AClass.new
+an_instance2 = AClass.new
 
-callback1 = callbacks_holder1.on(:event) { puts 'This is #1!' }
-callback2 = callbacks_holder2.on(:event) { puts 'This is #2!' }
+callback1 = an_instance1.on(:event) { puts 'This is #1!' }
+callback2 = an_instance2.on(:event) { puts 'This is #2!' }
 
-callbacks_holder1.trigger(:event) # => puts 'This is #1!'
-callbacks_holder2.trigger(:event) # => puts 'This is #2!'
+an_instance1.trigger(:event) # => puts 'This is #1!'
+an_instance2.trigger(:event) # => puts 'This is #2!'
 
-CallbacksHolder.trigger(:event) # => puts 'This is #1!' and 'This is #2!'
+AClass.trigger(:event) # => puts 'This is #1!' and 'This is #2!'
 
-callbacks_holder1.off(:event, callback)
-callbacks_holder2.off(:event, callback)
+an_instance1.off(:event, callback)
+an_instance2.off(:event, callback)
 ```
 
 The two methods `#once_on` and `#until_true_on` are available for instances,
-too, and work as you'd expect.
+too. They work as you'd expect.

data/callbacks_attachable.gemspec

@@ -1,17 +1,20 @@
 # coding: utf-8
-lib = File.expand_path('../lib', __FILE__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'callbacks_attachable/version'
+require_relative 'mrblib/version'
 
 Gem::Specification.new do |spec|
   spec.name          = "callbacks_attachable"
   spec.version       = CallbacksAttachable::VERSION
-  spec.authors       = ["Christopher Aue"]
-  spec.email         = ["mail@christopheraue.net"]
+  spec.summary       = %q{Attach callbacks to classes or individual instances.}
+  spec.description  = <<-DESC
+Attach callbacks to a class and trigger them for all its instances or just one
+particular instance. Additionally, instances can also have their own set of
+individual callbacks.
+  DESC
 
-  spec.summary       = %q{Attach callbacks to ruby objects. Then, trigger and detach them.}
   spec.homepage      = "https://github.com/christopheraue/ruby-callbacks_attachable"
   spec.license       = "MIT"
+  spec.authors       = ["Christopher Aue"]
+  spec.email         = "rubygems@christopheraue.net"
 
   spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
@@ -20,6 +23,4 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "bundler", "~> 1.8"
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "rspec", "~> 3.4"
-  spec.add_development_dependency "rspec-its"
-  spec.add_development_dependency "rspec-mocks-matchers-send_message", "~> 0.3"
 end

data/lib/callbacks_attachable.rb

@@ -1,64 +1,5 @@
-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(klass)
-    klass.extend ClassMethods
-  end
-
-  module ClassMethods
-    def on(*args, &block)
-      __callback_handler__.on(*args, &block)
-    end
-
-    def once_on(*args, &block)
-      __callback_handler__.once_on(*args, &block)
-    end
-
-    def until_true_on(*args, &block)
-      __callback_handler__.until_true_on(*args, &block)
-    end
-
-    def off(*args)
-      __callback_handler__.off(*args)
-    end
-
-    def trigger(*args)
-      __callback_handler__.trigger(*args)
-    end
-
-    private
-
-    def __callback_handler__
-      @__callback_handler__ ||= CallbackHandler.new(self, AllInstancesCallback)
-    end
-  end
-
-  def on(*args, &block)
-    __callback_handler__.on(*args, &block)
-  end
-
-  def once_on(*args, &block)
-    __callback_handler__.once_on(*args, &block)
-  end
-
-  def until_true_on(*args, &block)
-    __callback_handler__.until_true_on(*args, &block)
-  end
-
-  def off(*args)
-    __callback_handler__.off(*args)
-  end
-
-  def trigger(*args)
-    self.class.trigger(*args, instance: self) and __callback_handler__.trigger(*args)
-  end
-
-  private
-
-  def __callback_handler__
-    @__callback_handler__ ||= CallbackHandler.new(self, InstanceCallback)
-  end
-end
+require_relative "../mrblib/callbacks_attachable"
+require_relative "../mrblib/version"
+require_relative "../mrblib/callback_registry"
+require_relative "../mrblib/instance_callback"
+require_relative "../mrblib/all_instances_callback"

data/mrbgem.rake

@@ -0,0 +1,16 @@
+require_relative 'mrblib/version'
+
+MRuby::Gem::Specification.new('mruby-callbacks_attachable') do |spec|
+  spec.version      = CallbacksAttachable::VERSION
+  spec.summary      = %q{Attach callbacks to classes or individual instances.}
+  spec.description  = <<-DESC
+Attach callbacks to a class and trigger them for all its instances or just one
+particular instance. Additionally, instances can also have their own set of
+individual callbacks.
+DESC
+  spec.homepage     = "https://github.com/christopheraue/ruby-callbacks_attachable"
+  spec.license      = 'MIT'
+  spec.authors      = ['Christopher Aue']
+
+  spec.add_dependency 'mruby-objectspace', :core => 'mruby-objectspace'
+end

data/{lib/callbacks_attachable → mrblib}/all_instances_callback.rb

@@ -1,21 +1,13 @@
 module CallbacksAttachable
   class AllInstancesCallback
-    def initialize(klass, skip: 0, &callback)
+    def initialize(klass, opts = {}, &callback)
       @class = klass
-      @skip = skip
+      @skip = opts.fetch(:skip, 0)
       @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)
+    def call(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)

data/{lib/callbacks_attachable/callback_handler.rb → mrblib/callback_registry.rb}

@@ -1,13 +1,13 @@
 module CallbacksAttachable
-  class CallbackHandler
+  class CallbackRegistry
     def initialize(object, callback_class)
       @object = object
       @callback_class = callback_class
     end
 
-    def on(event, skip: 0, &callback)
+    def on(event, opts = {}, &callback)
       __callbacks__[event] ||= []
-      __callbacks__[event] << @callback_class.new(@object, skip: skip, &callback)
+      __callbacks__[event] << @callback_class.new(@object, opts, &callback)
       __callbacks__[event].last
     end
 
@@ -28,12 +28,12 @@ module CallbacksAttachable
       end
     end
 
-    def trigger(event, *args, **opts)
+    def trigger(instance, event, args)
       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) }
+      __callbacks__[event].dup.all?{ |callback| callback.call(instance, args) }
     end
 
     def off(event, callback)

data/mrblib/callbacks_attachable.rb

@@ -0,0 +1,59 @@
+module CallbacksAttachable
+  def self.included(klass)
+    klass.extend ClassMethods
+  end
+
+  module ClassMethods
+    def on(*args, &block)
+      __callback_registry__.on(*args, &block)
+    end
+
+    def once_on(*args, &block)
+      __callback_registry__.once_on(*args, &block)
+    end
+
+    def until_true_on(*args, &block)
+      __callback_registry__.until_true_on(*args, &block)
+    end
+
+    def off(*args)
+      __callback_registry__.off(*args)
+    end
+
+    def trigger(event, *args)
+      ObjectSpace.each_object(self).all?{ |inst| inst.trigger(event, *args) }
+    end
+
+    private
+
+    def __callback_registry__
+      @__callback_registry__ ||= CallbackRegistry.new(self, AllInstancesCallback)
+    end
+  end
+
+  def on(*args, &block)
+    __callback_registry__.on(*args, &block)
+  end
+
+  def once_on(*args, &block)
+    __callback_registry__.once_on(*args, &block)
+  end
+
+  def until_true_on(*args, &block)
+    __callback_registry__.until_true_on(*args, &block)
+  end
+
+  def off(*args)
+    __callback_registry__.off(*args)
+  end
+
+  def trigger(event, *args)
+    self.class.__send__(:__callback_registry__).trigger(self, event, args) and __callback_registry__.trigger(self, event, args)
+  end
+
+  private
+
+  def __callback_registry__
+    @__callback_registry__ ||= CallbackRegistry.new(self, InstanceCallback)
+  end
+end

data/{lib/callbacks_attachable → mrblib}/instance_callback.rb

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

data/{lib/callbacks_attachable → mrblib}/version.rb

@@ -1,3 +1,3 @@
 module CallbacksAttachable
-  VERSION = "1.0.3"
+  VERSION = "1.1.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: callbacks_attachable
 version: !ruby/object:Gem::Version
-  version: 1.0.3
+  version: 1.1.0
 platform: ruby
 authors:
 - Christopher Aue
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-03-10 00:00:00.000000000 Z
+date: 2016-12-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -52,37 +52,11 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.4'
-- !ruby/object:Gem::Dependency
-  name: rspec-its
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: rspec-mocks-matchers-send_message
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.3'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.3'
-description: 
-email:
-- mail@christopheraue.net
+description: |
+  Attach callbacks to a class and trigger them for all its instances or just one
+  particular instance. Additionally, instances can also have their own set of
+  individual callbacks.
+email: rubygems@christopheraue.net
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -92,13 +66,14 @@ files:
 - Gemfile
 - LICENSE.txt
 - README.md
-- 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
+- mrbgem.rake
+- mrblib/all_instances_callback.rb
+- mrblib/callback_registry.rb
+- mrblib/callbacks_attachable.rb
+- mrblib/instance_callback.rb
+- mrblib/version.rb
 homepage: https://github.com/christopheraue/ruby-callbacks_attachable
 licenses:
 - MIT
@@ -119,8 +94,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5.1
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
-summary: Attach callbacks to ruby objects. Then, trigger and detach them.
+summary: Attach callbacks to classes or individual instances.
 test_files: []
+has_rdoc: 

data/Rakefile

@@ -1,2 +0,0 @@
-require "bundler/gem_tasks"
-