callbacky 0.1.3.1 → 0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b7e1ea725774c4dd07097acebe90266cbcfe6090173fc72562bf5d1e255972a6
-  data.tar.gz: 7ad89a95e9805f784674238bea4fc55502280f2a992f8ce46e5a69db9d71a7b1
+  metadata.gz: 5682ae87ad43e4d13e0cc1ab6bd323c4fc54ac673dfdc0b9781cd5ac85581f1c
+  data.tar.gz: c048bd4af9d3f821151b9270717328f61ba57da0e8d76ec8abe721a53f5d7a18
 SHA512:
-  metadata.gz: b5872e8d7f10d7481ba58ca25fb4e99bf63dae4129f222935ab0f0e5fb28f4c10cb9a6aef249bb407b36ec399046105923bd0d952e243a2f76a2ac43554cc1a1
-  data.tar.gz: 9423b758a4e91f871577d14f5220ddfe2b83442d5897a02c531d48a6c624fa43e3664e2c929c50373a9595e0afb4b5daaebcb609122a1cd2c22a7b1457d4c75e
+  metadata.gz: 13124ff72116bad7ad4b536c4ae5ce9beb57d372957279b851840a0539fcd330171811d11c765d119e1d2bca25e82ea5bdc266c39583aa0c9181823c4370f989
+  data.tar.gz: ca8551e470afd392e711ae4c4efb7b9c524e482c80ce3aaeaec73e7e0eb292008c0dce9ae8dc1e43bbdc40f601d68436f208ea2ec0c7594218f72dd1c16105c7

data/README.md

@@ -25,56 +25,56 @@ gem install callbacky
 
 ## Usage
 
-### 1. Extend `Callbacky` in your class
+### 1. Include `Callbacky` in your class
 ```ruby
 class MyService
-  class << self
-    extend Callbacky
-
-    callbacky_after :init
-  end
+  include Callbacky
 end
 ```
-### 2. Define a callback
+### 2. Define callbacks
 
 ***Using method name:***
 ```ruby
 class MyService
-  callbacky_after_init :handle_after_init
+  include Callbacky
+
+  callbacky :before, :init, :prepare_context
+  callbacky :after, :init, ->(obj) { obj.log_init }
 
-  def handle_after_init
-    puts "After init"
+  callbacky :after, :init do |instance|
+    instance.send_metrics
   end
-end
-```
 
-***Using a lambda or proc:***
-```ruby
-class MyService
-  callbacky_after_init ->(obj) { obj.log_event }
-end
-```
+  def prepare_context
+    puts "Preparing context"
+  end
 
-***Using a block:***
-```ruby
-class MyService
-  callbacky_after_init do |instance|
-    instance.send_metrics
+  def log_init
+    puts "Logged init"
+  end
+
+  def send_metrics
+    puts "Sent metrics"
   end
 end
+
 ```
 
 ### 3. Trigger the callback
 
 ```ruby
 class MyService
-  def initializer
-    ### callbacky_init will run before and after hooks
-    callbacky_init do |instance|
-      instance.do_some_other_things_inside
+  def initialize
+    callbacky_init
+      do_work
     end
   end
+
+  def do_work
+    puts "Doing the actual work"
+  end
 end
+
 ```
 
 ## Development

data/lib/callbacky/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Callbacky
-  VERSION = "0.1.3.1"
+  VERSION = "0.2"
 end

data/lib/callbacky.rb

@@ -1,36 +1,45 @@
 # frozen_string_literal: true
 
-require_relative "callbacky/version"
-
 module Callbacky
-  VALID_LIFECYCLES = %i[before after].freeze
-  class << self
-    def define_callback(lifecycle_event)
-      unless VALID_LIFECYCLES.include?(lifecycle_event)
-        raise ArgumentError,
-              "Valid life cycles are: #{VALID_LIFECYCLES}. #{lifecycle_event} was passed"
+  module ClassMethods
+    def callbacky_callbacks
+      @callbacky_callbacks ||= Hash.new do |events_hash, event|
+        events_hash[event] = Hash.new { |methods_hash, cycle| methods_hash[cycle] = [] }
       end
+    end
+
+    def callbacky(cycle, event, *methods, &block)
+      store_callbacks(cycle, event, *methods, &block)
+      define_callback_executor(event) unless method_defined?("callbacky_#{event}")
+    end
+
+    private
 
-      define_method("callbacky_#{lifecycle_event}") do |event|
-        define_method("callbacky_#{lifecycle_event}_#{event}") do |callback_method_or_block = nil, &block|
-          kallbacks = instance_variable_get("@#{lifecycle_event}_kallbacks") || []
-          kallbacks << callback_method_or_block if callback_method_or_block
-          kallbacks << block if block
-          instance_variable_set("@#{lifecycle_event}_kallbacks", kallbacks)
-        end
-
-        define_method("callbacky_#{event}") do |obj, &block|
-          before_kallbacks = instance_variable_get(:@before_kallbacks)
-          before_kallbacks.each { |it| it.is_a?(Proc) ? it.call(obj) : obj.send(it) } if before_kallbacks
-          yield if block
-          after_kallbacks = instance_variable_get(:@after_kallbacks)
-          after_kallbacks.each { |it| it.is_a?(Proc) ? it.call(obj) : obj.send(it) } if after_kallbacks
-        end
+    def store_callbacks(cycle, event, *methods, &block)
+      callbacks = callbacky_callbacks[event][cycle]
+      methods.each { |method| callbacks << method unless callbacks.include?(method) }
+      callbacks << block if block_given?
+    end
+
+    def define_callback_executor(event)
+      define_method("callbacky_#{event}") do |&block|
+        run_callback_cycle(:before, event)
+        block&.call(self)
+        run_callback_cycle(:after, event)
       end
     end
   end
 
-  VALID_LIFECYCLES.each do |it|
-    define_callback(it)
+  def self.included(base)
+    base.extend(ClassMethods)
+  end
+
+  private
+
+  def run_callback_cycle(cycle, event)
+    callbacks = self.class.callbacky_callbacks.dig(event, cycle) || []
+    callbacks.each do |callback|
+      callback.is_a?(Proc) ? callback.call(self) : send(callback)
+    end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: callbacky
 version: !ruby/object:Gem::Version
-  version: 0.1.3.1
+  version: '0.2'
 platform: ruby
 authors:
 - pucinsk