super_callbacks 1.1.2 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3fd64d5b5a8b0fb21cbafcc317f899179a7963e8
-  data.tar.gz: 7e4297e1e6fcaf6d3ee7bf9f0a4ca496e441968e
+  metadata.gz: 1421ece86724a74cf1d418b8d78149445cf42147
+  data.tar.gz: 3fbe860e516f3b0f68a4025b2e8200218a2c7a56
 SHA512:
-  metadata.gz: e2e56689fd4acb40b21350965389c379a6a8dd6315b0012f148807853dc6500d1f5e9533538ba0870ae054969c9e51b54c4d06056bdcc7fe069e488f67008feb
-  data.tar.gz: db281bec9a46bf31edb20e4d11b833daa1871c061242f9161bea66fd5f085bfb6b1c8e1ceab7228f5011f18f82932757ad1493c4ae64474eeadc53d19b833f05
+  metadata.gz: 336f098ce35d7485319a625558df3e224eaac0e4fe0afc1b5eec0c08c7c1d290ff8ed87e0e7d518609ca0e6ef17bce86196011ca32b2d773d66eb3c0096c50b9
+  data.tar.gz: bdc621d66c9712b031b63a313e879fbe112ef448407ff8790f77137b03dc8d43432f8d5040d8f4617f895678eb6339ed266498c95fbf612c252df01317be6928

data/.ruby-version

@@ -1 +1 @@
-2.2.10
+2.2.10

data/README.md

@@ -23,7 +23,7 @@
 Add this line to your application's Gemfile:
 
 ```ruby
-gem 'super_callbacks', '~> 1.1'
+gem 'super_callbacks', '~> 1.2'
 ```
 
 And then execute:
@@ -425,6 +425,10 @@ The gem is available as open source under the terms of the [MIT License](https:/
 
 ## Changelog
 
+* 1.2.0 (2019-08-15)
+    * [Fixed / Supported Nested "Dirty" Changes on nested callbacks for idempotency (Thread-safe)](https://github.com/jrpolidario/super_callbacks/blob/4e9284e1c6150c6d5da536766d51b4e635bb819d/spec/super_callbacks_spec.rb#L487)
+    * Housecleaning: segregated super_callbacks.rb into multiple files.
+    * Now puts "overriden" warning messages when `SuperCallbacks` is included to a class which already has methods conflicting `SuperCallback`'s DSL-methods.
 * 1.1.2 (2019-08-14)
     * [Supported "dirty" checking of instance variable changes](#example-10-dirty-checking-of-instance-variables-changes)
 * 1.0.3 (2019-08-12)

data/lib/super_callbacks.rb

@@ -1,4 +1,9 @@
 require 'super_callbacks/version'
+require 'super_callbacks/helpers'
+require 'super_callbacks/prepended'
+require 'super_callbacks/class_methods'
+require 'super_callbacks/instance_methods'
+require 'super_callbacks/class_and_instance_methods'
 
 module SuperCallbacks
   VALID_OPTION_KEYS = [:if].freeze
@@ -7,6 +12,8 @@ module SuperCallbacks
     # prevent re-including
     return if base.ancestors.detect { |ancestor| ancestor.is_a? SuperCallbacks::Prepended }
 
+    puts_warning_messages_when_methods_already_defined(base)
+
     base.singleton_class.send :attr_accessor, *[:before_callbacks, :after_callbacks]
     base.send :attr_accessor, *[:before_callbacks, :after_callbacks]
     base.extend ClassMethods
@@ -16,239 +23,41 @@ module SuperCallbacks
     base.send :prepend, Prepended.new
   end
 
-  class Prepended < Module
-  end
-
-  module Helpers
-    # (modified) File activesupport/lib/active_support/core_ext/hash/deep_merge.rb, line 18
-    def self.deep_merge_hashes_and_combine_arrays(this_hash, other_hash, &block)
-      self.deep_merge_hashes_and_combine_arrays!(this_hash.dup, other_hash, &block)
-    end
-
-    # (modified) File activesupport/lib/active_support/core_ext/hash/deep_merge.rb, line 23
-    def self.deep_merge_hashes_and_combine_arrays!(this_hash, other_hash, &block)
-      this_hash.merge!(other_hash) do |key, this_val, other_val|
-        if this_val.is_a?(Hash) && other_val.is_a?(Hash)
-          self.deep_merge_hashes(this_val, other_val, &block)
-        elsif this_val.is_a?(Array) && other_val.is_a?(Array)
-          this_val + other_val
-        elsif block_given?
-          block.call(key, this_val, other_val)
-        else
-          other_val
-        end
-      end
-    end
-  end
-
-  module ClassAndInstanceMethods
-    def before!(method_name, *remaining_args, &callback_proc)
-      raise ArgumentError, "`#{method_name}` is not or not yet defined for #{self}" unless method_defined? method_name
-      before(method_name, *remaining_args, &callback_proc)
-    end
-
-    def after!(method_name, *remaining_args, &callback_proc)
-      raise ArgumentError, "`#{method_name}` is not or not yet defined for #{self}" unless method_defined? method_name
-      after(method_name, *remaining_args, &callback_proc)
-    end
-
-    def before(method_name, callback_method_name = nil, options = {}, &callback_proc)
-      callback_method_name_or_proc = callback_proc || callback_method_name
-      unless [Symbol, String, Proc].any? { |klass| callback_method_name_or_proc.is_a? klass }
-        raise ArgumentError, "Only `Symbol`, `String` or `Proc` allowed for `method_name`, but is #{callback_method_name_or_proc.class}"
-      end
-
-      invalid_option_keys = options.keys - VALID_OPTION_KEYS
-      unless invalid_option_keys.empty?
-        raise ArgumentError, "Invalid `options` keys: #{invalid_option_keys}. Valid are only: #{VALID_OPTION_KEYS}"
-      end
-      if options[:if] && !([Symbol, String, Proc].any? { |klass| callback_method_name_or_proc.is_a? klass })
-        raise ArgumentError, "Only `Symbol`, `String` or `Proc` allowed for `options[:if]`, but is #{options[:if].class}"
-      end
-
-      self.before_callbacks ||= {}
-      self.before_callbacks[method_name.to_sym] ||= []
-      self.before_callbacks[method_name.to_sym] << [callback_method_name_or_proc, options[:if]]
-
-      _callbacks_prepended_module_instance = callbacks_prepended_module_instance
-
-      # dont redefine, to save cpu cycles
-      unless _callbacks_prepended_module_instance.method_defined? method_name
-        _callbacks_prepended_module_instance.send(:define_method, method_name) do |*args|
-          begin
-            @instance_variables_before_change = instance_variables.each_with_object({}) do |instance_variable, hash|
-              hash[instance_variable] = instance_variable_get(instance_variable)
-            end
-
-            run_before_callbacks(method_name, *args)
-            super_value = super(*args)
-            run_after_callbacks(method_name, *args)
-          ensure
-            remove_instance_variable(:@instance_variables_before_change)
-          end
-
-          super_value
-        end
-      end
-    end
-
-    def after(method_name, callback_method_name = nil, options = {}, &callback_proc)
-      callback_method_name_or_proc = callback_proc || callback_method_name
-      unless [Symbol, String, Proc].include? callback_method_name_or_proc.class
-        raise ArgumentError, "Only `Symbol`, `String` or `Proc` allowed for `method_name`, but is #{callback_method_name_or_proc.class}"
-      end
-
-      invalid_option_keys = options.keys - VALID_OPTION_KEYS
-      unless invalid_option_keys.empty?
-        raise ArgumentError, "Invalid `options` keys: #{invalid_option_keys}. Valid are only: #{VALID_OPTION_KEYS}"
-      end
-      if options[:if] && ![Symbol, String, Proc].include?(options[:if].class)
-        raise ArgumentError, "Only `Symbol`, `String` or `Proc` allowed for `options[:if]`, but is #{options[:if].class}"
-      end
-
-      self.after_callbacks ||= {}
-      self.after_callbacks[method_name.to_sym] ||= []
-      self.after_callbacks[method_name.to_sym] << [callback_method_name_or_proc, options[:if]]
-
-      _callbacks_prepended_module_instance = callbacks_prepended_module_instance
-
-      # dont redefine, to save cpu cycles
-      unless _callbacks_prepended_module_instance.method_defined? method_name
-        _callbacks_prepended_module_instance.send(:define_method, method_name) do |*args|
-          begin
-            @instance_variables_before_change = instance_variables.each_with_object({}) do |instance_variable, hash|
-              hash[instance_variable] = instance_variable_get(instance_variable)
-            end
-
-            run_before_callbacks(method_name, *args)
-            super_value = super(*args)
-            run_after_callbacks(method_name, *args)
-          ensure
-            remove_instance_variable(:@instance_variables_before_change)
-          end
-
-          super_value
-        end
-      end
-    end
-
-    def instance_variables_before_change
-      @instance_variables_before_change
-    end
-
-    def instance_variable_before_change(instance_variable)
-      raise ArgumentError, "#{instance_variable} should be a string that starts with `@`" unless instance_variable.to_s.start_with? '@'
-      raise 'You cannot call this method outside the SuperCallback cycle' if instance_variables_before_change.nil?
-      instance_variables_before_change[instance_variable.to_sym]
-    end
-
-    def instance_variable_changed?(instance_variable)
-      raise ArgumentError, "#{instance_variable} should be a string that starts with `@`" unless instance_variable.to_s.start_with? '@'
-      raise 'You cannot call this method outside the SuperCallback cycle' if instance_variables_before_change.nil?
-
-      before_change_value = instance_variable_before_change(instance_variable.to_sym)
-      current_value = instance_variable_get(instance_variable)
-      before_change_value != current_value
-    end
-
-    # TODO
-    # def around
-    # end
-  end
-
-  module ClassMethods
-
-    private
-
-    def callbacks_prepended_module_instance
-      ancestors.reverse.detect { |ancestor| ancestor.is_a? SuperCallbacks::Prepended }
-    end
-  end
-
-  module InstanceMethods
-    # TODO: optimize by instead of dynamically getting all_ancestral_after_callbacks on runtime
-    # set them immediately when `include` is called on Base class
-    def run_before_callbacks(method_name, *args)
-      all_ancestral_before_callbacks = self.class.ancestors.reverse.each_with_object({}) do |ancestor, hash|
-        SuperCallbacks::Helpers.deep_merge_hashes_and_combine_arrays!(
-          hash,
-          ancestor.instance_variable_get(:@before_callbacks) || {}
+  private
+
+  def self.puts_warning_messages_when_methods_already_defined(base)
+    overriden_instance_methods = (
+      base.instance_methods(false) & (
+        (
+          SuperCallbacks::ClassAndInstanceMethods.instance_methods(false) +
+          SuperCallbacks::ClassAndInstanceMethods.private_instance_methods(false)
+        ) |
+        (
+          SuperCallbacks::InstanceMethods.instance_methods(false) +
+          SuperCallbacks::InstanceMethods.private_instance_methods(false)
         )
-      end
-
-      singleton_class_before_callbacks = instance_variable_get(:@before_callbacks) || {}
-
-      all_before_callbacks = SuperCallbacks::Helpers.deep_merge_hashes_and_combine_arrays(
-        all_ancestral_before_callbacks,
-        singleton_class_before_callbacks
       )
+    ).sort
 
-      all_before_callbacks_on_method = all_before_callbacks[method_name] || []
-
-      all_before_callbacks_on_method.each do |before_callback, options_if|
-        is_condition_truthy = true
-
-        if options_if
-          is_condition_truthy = instance_exec *args, &options_if
-        end
-
-        if is_condition_truthy
-          if before_callback.is_a? Proc
-            instance_exec *args, &before_callback
-          else
-            send before_callback
-          end
-        end
-      end
+    unless overriden_instance_methods.empty?
+      puts "WARN: SuperCallbacks will override #{base} the following already existing instance methods: #{overriden_instance_methods}"
     end
 
-    # TODO: optimize by instead of dynamically getting all_ancestral_after_callbacks on runtime
-    # set them immediately when `include` is called on Base class
-    def run_after_callbacks(method_name, *args)
-      all_ancestral_after_callbacks = self.class.ancestors.reverse.each_with_object({}) do |ancestor, hash|
-        SuperCallbacks::Helpers.deep_merge_hashes_and_combine_arrays!(
-          hash,
-          ancestor.instance_variable_get(:@after_callbacks) || {}
+    overriden_class_methods = (
+      base.methods(false) & (
+        (
+          SuperCallbacks::ClassAndInstanceMethods.instance_methods(false) +
+          SuperCallbacks::ClassAndInstanceMethods.private_instance_methods(false)
+        ) |
+        (
+          SuperCallbacks::ClassMethods.instance_methods(false) +
+          SuperCallbacks::ClassMethods.private_instance_methods(false)
         )
-      end
-
-      singleton_class_after_callbacks = instance_variable_get(:@after_callbacks) || {}
-
-      all_after_callbacks = SuperCallbacks::Helpers.deep_merge_hashes_and_combine_arrays(
-        all_ancestral_after_callbacks,
-        singleton_class_after_callbacks
       )
+    ).sort
 
-      all_after_callbacks_on_method = all_after_callbacks[method_name] || []
-
-      all_after_callbacks_on_method.each do |after_callback, options_if|
-        is_condition_truthy = true
-
-        if options_if
-          is_condition_truthy = instance_exec *args, &options_if
-        end
-
-        if is_condition_truthy
-          if after_callback.is_a? Proc
-            instance_exec *args, &after_callback
-          else
-            send after_callback
-          end
-        end
-      end
-    end
-
-    private
-
-    def callbacks_prepended_module_instance
-      _callbacks_prepended_module_instance = self.singleton_class.ancestors.reverse.detect { |ancestor| ancestor.is_a? SuperCallbacks::Prepended }
-
-      if _callbacks_prepended_module_instance.nil?
-        self.singleton_class.prepend SuperCallbacks::Prepended
-        _callbacks_prepended_module_instance = self.singleton_class.ancestors.reverse.detect { |ancestor| ancestor.is_a? SuperCallbacks::Prepended }
-      end
-
-      _callbacks_prepended_module_instance
+    unless overriden_class_methods.empty?
+      puts "WARN: SuperCallbacks will override #{base} the following already existing class methods: #{overriden_class_methods}"
     end
   end
 end

data/lib/super_callbacks/class_and_instance_methods.rb

@@ -0,0 +1,146 @@
+module SuperCallbacks
+  # The methods defined here will be available "class" and "instance" for any class where SuperCallbacks is included
+  module ClassAndInstanceMethods
+    def before!(method_name, *remaining_args, &callback_proc)
+      raise ArgumentError, "`#{method_name}` is not or not yet defined for #{self}" unless method_defined? method_name
+      before(method_name, *remaining_args, &callback_proc)
+    end
+
+    def after!(method_name, *remaining_args, &callback_proc)
+      raise ArgumentError, "`#{method_name}` is not or not yet defined for #{self}" unless method_defined? method_name
+      after(method_name, *remaining_args, &callback_proc)
+    end
+
+    def before(method_name, callback_method_name = nil, options = {}, &callback_proc)
+      callback_method_name_or_proc = callback_proc || callback_method_name
+      unless [Symbol, String, Proc].any? { |klass| callback_method_name_or_proc.is_a? klass }
+        raise ArgumentError, "Only `Symbol`, `String` or `Proc` allowed for `method_name`, but is #{callback_method_name_or_proc.class}"
+      end
+
+      invalid_option_keys = options.keys - VALID_OPTION_KEYS
+      unless invalid_option_keys.empty?
+        raise ArgumentError, "Invalid `options` keys: #{invalid_option_keys}. Valid are only: #{VALID_OPTION_KEYS}"
+      end
+      if options[:if] && !([Symbol, String, Proc].any? { |klass| callback_method_name_or_proc.is_a? klass })
+        raise ArgumentError, "Only `Symbol`, `String` or `Proc` allowed for `options[:if]`, but is #{options[:if].class}"
+      end
+
+      self.before_callbacks ||= {}
+      self.before_callbacks[method_name.to_sym] ||= []
+      self.before_callbacks[method_name.to_sym] << [callback_method_name_or_proc, options[:if]]
+
+      _callbacks_prepended_module_instance = callbacks_prepended_module_instance
+
+      # dont redefine, to save cpu cycles
+      unless _callbacks_prepended_module_instance.method_defined? method_name
+        _callbacks_prepended_module_instance.send(:define_method, method_name) do |*args|
+          begin
+            # refactored to use Thread.current for thread-safetiness
+            Thread.current[:super_callbacks_all_instance_variables_before_change] ||= {}
+            Thread.current[:super_callbacks_all_instance_variables_before_change][object_id] ||= []
+
+            all_instance_variables_before_change = instance_variables.each_with_object({}) do |instance_variable, hash|
+              hash[instance_variable] = instance_variable_get(instance_variable)
+            end
+
+            Thread.current[:super_callbacks_all_instance_variables_before_change][object_id] << all_instance_variables_before_change
+
+            run_before_callbacks(method_name, *args)
+            super_value = super(*args)
+            run_after_callbacks(method_name, *args)
+          ensure
+            Thread.current[:super_callbacks_all_instance_variables_before_change][object_id].pop
+
+            if Thread.current[:super_callbacks_all_instance_variables_before_change][object_id].empty?
+              Thread.current[:super_callbacks_all_instance_variables_before_change].delete(object_id)
+            end
+
+            if Thread.current[:super_callbacks_all_instance_variables_before_change].empty?
+              Thread.current[:super_callbacks_all_instance_variables_before_change] = nil
+            end
+          end
+
+          super_value
+        end
+      end
+    end
+
+    def after(method_name, callback_method_name = nil, options = {}, &callback_proc)
+      callback_method_name_or_proc = callback_proc || callback_method_name
+      unless [Symbol, String, Proc].include? callback_method_name_or_proc.class
+        raise ArgumentError, "Only `Symbol`, `String` or `Proc` allowed for `method_name`, but is #{callback_method_name_or_proc.class}"
+      end
+
+      invalid_option_keys = options.keys - VALID_OPTION_KEYS
+      unless invalid_option_keys.empty?
+        raise ArgumentError, "Invalid `options` keys: #{invalid_option_keys}. Valid are only: #{VALID_OPTION_KEYS}"
+      end
+      if options[:if] && ![Symbol, String, Proc].include?(options[:if].class)
+        raise ArgumentError, "Only `Symbol`, `String` or `Proc` allowed for `options[:if]`, but is #{options[:if].class}"
+      end
+
+      self.after_callbacks ||= {}
+      self.after_callbacks[method_name.to_sym] ||= []
+      self.after_callbacks[method_name.to_sym] << [callback_method_name_or_proc, options[:if]]
+
+      _callbacks_prepended_module_instance = callbacks_prepended_module_instance
+
+      # dont redefine, to save cpu cycles
+      unless _callbacks_prepended_module_instance.method_defined? method_name
+        _callbacks_prepended_module_instance.send(:define_method, method_name) do |*args|
+          begin
+            # refactored to use Thread.current for thread-safetiness
+            Thread.current[:super_callbacks_all_instance_variables_before_change] ||= {}
+            Thread.current[:super_callbacks_all_instance_variables_before_change][object_id] ||= []
+
+            all_instance_variables_before_change = instance_variables.each_with_object({}) do |instance_variable, hash|
+              hash[instance_variable] = instance_variable_get(instance_variable)
+            end
+
+            Thread.current[:super_callbacks_all_instance_variables_before_change][object_id] << all_instance_variables_before_change
+            
+            run_before_callbacks(method_name, *args)
+            super_value = super(*args)
+            run_after_callbacks(method_name, *args)
+          ensure
+            Thread.current[:super_callbacks_all_instance_variables_before_change][object_id].pop
+
+            if Thread.current[:super_callbacks_all_instance_variables_before_change][object_id].empty?
+              Thread.current[:super_callbacks_all_instance_variables_before_change].delete(object_id)
+            end
+
+            if Thread.current[:super_callbacks_all_instance_variables_before_change].empty?
+              Thread.current[:super_callbacks_all_instance_variables_before_change] = nil
+            end
+          end
+
+          super_value
+        end
+      end
+    end
+
+    def instance_variables_before_change
+      raise 'You cannot call this method outside the SuperCallback cycle' if Thread.current[:super_callbacks_all_instance_variables_before_change].nil?
+      Thread.current[:super_callbacks_all_instance_variables_before_change][object_id].last
+    end
+
+    def instance_variable_before_change(instance_variable)
+      raise 'You cannot call this method outside the SuperCallback cycle' if Thread.current[:super_callbacks_all_instance_variables_before_change].nil?
+      raise ArgumentError, "#{instance_variable} should be a string that starts with `@`" unless instance_variable.to_s.start_with? '@'
+      instance_variables_before_change[instance_variable.to_sym]
+    end
+
+    def instance_variable_changed?(instance_variable)
+      raise 'You cannot call this method outside the SuperCallback cycle' if Thread.current[:super_callbacks_all_instance_variables_before_change].nil?
+      raise ArgumentError, "#{instance_variable} should be a string that starts with `@`" unless instance_variable.to_s.start_with? '@'
+
+      before_change_value = instance_variable_before_change(instance_variable.to_sym)
+      current_value = instance_variable_get(instance_variable)
+      before_change_value != current_value
+    end
+
+    # TODO
+    # def around
+    # end
+  end
+end

data/lib/super_callbacks/class_methods.rb

@@ -0,0 +1,10 @@
+module SuperCallbacks
+  # The methods defined here will be available "class" methods for any class where SuperCallbacks is included
+  module ClassMethods
+    private
+
+    def callbacks_prepended_module_instance
+      ancestors.reverse.detect { |ancestor| ancestor.is_a? SuperCallbacks::Prepended }
+    end
+  end
+end

data/lib/super_callbacks/helpers.rb

@@ -0,0 +1,23 @@
+module SuperCallbacks
+  module Helpers
+    # (modified) File activesupport/lib/active_support/core_ext/hash/deep_merge.rb, line 18
+    def self.deep_merge_hashes_and_combine_arrays(this_hash, other_hash, &block)
+      self.deep_merge_hashes_and_combine_arrays!(this_hash.dup, other_hash, &block)
+    end
+
+    # (modified) File activesupport/lib/active_support/core_ext/hash/deep_merge.rb, line 23
+    def self.deep_merge_hashes_and_combine_arrays!(this_hash, other_hash, &block)
+      this_hash.merge!(other_hash) do |key, this_val, other_val|
+        if this_val.is_a?(Hash) && other_val.is_a?(Hash)
+          self.deep_merge_hashes(this_val, other_val, &block)
+        elsif this_val.is_a?(Array) && other_val.is_a?(Array)
+          this_val + other_val
+        elsif block_given?
+          block.call(key, this_val, other_val)
+        else
+          other_val
+        end
+      end
+    end
+  end
+end

data/lib/super_callbacks/instance_methods.rb

@@ -0,0 +1,89 @@
+module SuperCallbacks
+  # The methods defined here will be available "class" methods for any class where SuperCallbacks is included
+  module InstanceMethods
+    # TODO: optimize by instead of dynamically getting all_ancestral_after_callbacks on runtime
+    # set them immediately when `include` is called on Base class
+    def run_before_callbacks(method_name, *args)
+      all_ancestral_before_callbacks = self.class.ancestors.reverse.each_with_object({}) do |ancestor, hash|
+        SuperCallbacks::Helpers.deep_merge_hashes_and_combine_arrays!(
+          hash,
+          ancestor.instance_variable_get(:@before_callbacks) || {}
+        )
+      end
+
+      singleton_class_before_callbacks = instance_variable_get(:@before_callbacks) || {}
+
+      all_before_callbacks = SuperCallbacks::Helpers.deep_merge_hashes_and_combine_arrays(
+        all_ancestral_before_callbacks,
+        singleton_class_before_callbacks
+      )
+
+      all_before_callbacks_on_method = all_before_callbacks[method_name] || []
+
+      all_before_callbacks_on_method.each do |before_callback, options_if|
+        is_condition_truthy = true
+
+        if options_if
+          is_condition_truthy = instance_exec *args, &options_if
+        end
+
+        if is_condition_truthy
+          if before_callback.is_a? Proc
+            instance_exec *args, &before_callback
+          else
+            send before_callback
+          end
+        end
+      end
+    end
+
+    # TODO: optimize by instead of dynamically getting all_ancestral_after_callbacks on runtime
+    # set them immediately when `include` is called on Base class
+    def run_after_callbacks(method_name, *args)
+      all_ancestral_after_callbacks = self.class.ancestors.reverse.each_with_object({}) do |ancestor, hash|
+        SuperCallbacks::Helpers.deep_merge_hashes_and_combine_arrays!(
+          hash,
+          ancestor.instance_variable_get(:@after_callbacks) || {}
+        )
+      end
+
+      singleton_class_after_callbacks = instance_variable_get(:@after_callbacks) || {}
+
+      all_after_callbacks = SuperCallbacks::Helpers.deep_merge_hashes_and_combine_arrays(
+        all_ancestral_after_callbacks,
+        singleton_class_after_callbacks
+      )
+
+      all_after_callbacks_on_method = all_after_callbacks[method_name] || []
+
+      all_after_callbacks_on_method.each do |after_callback, options_if|
+        is_condition_truthy = true
+
+        if options_if
+          is_condition_truthy = instance_exec *args, &options_if
+        end
+
+        if is_condition_truthy
+          if after_callback.is_a? Proc
+            instance_exec *args, &after_callback
+          else
+            send after_callback
+          end
+        end
+      end
+    end
+
+    private
+
+    def callbacks_prepended_module_instance
+      _callbacks_prepended_module_instance = self.singleton_class.ancestors.reverse.detect { |ancestor| ancestor.is_a? SuperCallbacks::Prepended }
+
+      if _callbacks_prepended_module_instance.nil?
+        self.singleton_class.prepend SuperCallbacks::Prepended
+        _callbacks_prepended_module_instance = self.singleton_class.ancestors.reverse.detect { |ancestor| ancestor.is_a? SuperCallbacks::Prepended }
+      end
+
+      _callbacks_prepended_module_instance
+    end
+  end
+end

data/lib/super_callbacks/prepended.rb

@@ -0,0 +1,9 @@
+# This is the module that will be prepended to the base (target) class where `include SuperCallbacks`
+# have been called. This will be always a new instance of a Module, and will not be a permanent
+# Module. This is important because, this module-instance is used by SuperCallbacks to define
+# the methods whenever `before` or `after` is called. These defined methods here will then have a
+# `super` inside it, which then will also call the "real" method defined in the target class.
+module SuperCallbacks
+  class Prepended < Module
+  end
+end

data/lib/super_callbacks/version.rb

@@ -1,3 +1,3 @@
 module SuperCallbacks
-  VERSION = '1.1.2'
+  VERSION = '1.2.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: super_callbacks
 version: !ruby/object:Gem::Version
-  version: 1.1.2
+  version: 1.2.0
 platform: ruby
 authors:
 - Jules Roman B. Polidario
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-08-14 00:00:00.000000000 Z
+date: 2019-08-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -87,6 +87,11 @@ files:
 - bin/console
 - bin/setup
 - lib/super_callbacks.rb
+- lib/super_callbacks/class_and_instance_methods.rb
+- lib/super_callbacks/class_methods.rb
+- lib/super_callbacks/helpers.rb
+- lib/super_callbacks/instance_methods.rb
+- lib/super_callbacks/prepended.rb
 - lib/super_callbacks/version.rb
 - super_callbacks.gemspec
 homepage: https://github.com/jrpolidario/super_callbacks