super_callbacks 1.2.0 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1421ece86724a74cf1d418b8d78149445cf42147
-  data.tar.gz: 3fbe860e516f3b0f68a4025b2e8200218a2c7a56
+  metadata.gz: a9de4f62f5259330dd9c9043dcd6e9e5faa50bfb
+  data.tar.gz: 5428ec46f89d68264b01e11d2ab32a9ac076834d
 SHA512:
-  metadata.gz: 336f098ce35d7485319a625558df3e224eaac0e4fe0afc1b5eec0c08c7c1d290ff8ed87e0e7d518609ca0e6ef17bce86196011ca32b2d773d66eb3c0096c50b9
-  data.tar.gz: bdc621d66c9712b031b63a313e879fbe112ef448407ff8790f77137b03dc8d43432f8d5040d8f4617f895678eb6339ed266498c95fbf612c252df01317be6928
+  metadata.gz: 7416ac8af83da5407af6113f103b28dee8729086b0e9f2cc53b689252abe4883c23cdaeff553102761a8b5dbf16222d40ca009e0fff5ee273a03eb2633a0e308
+  data.tar.gz: 3c984287755e49a18b8b5b3e46ee6a95911ca9e7bf5b9e86e922638c4329b73a3d5166264aa62647930d021bdf00e711a8537af78e18838a1bfedbb82148d042

data/README.md

@@ -23,7 +23,7 @@
 Add this line to your application's Gemfile:
 
 ```ruby
-gem 'super_callbacks', '~> 1.2'
+gem 'super_callbacks', '~> 1.3'
 ```
 
 And then execute:
@@ -425,6 +425,9 @@ The gem is available as open source under the terms of the [MIT License](https:/
 
 ## Changelog
 
+* [1.3.0 (2019-08-15)](https://github.com/jrpolidario/super_callbacks/commit/dcc71648d9be06074280c936add04b6b3f921e10)
+    * [Fixed difficult bug: callbacks not in order when method defined in subclass and not in superclass when using inherited callbacks](https://github.com/jrpolidario/super_callbacks/issues/1
+    * Refactored a lot of code, and added slight overhead. I'm satisfied at the moment until I could find the best solution.
 * 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.

data/lib/super_callbacks.rb

@@ -20,7 +20,80 @@ module SuperCallbacks
     base.send :include, InstanceMethods
     base.extend ClassAndInstanceMethods
     base.send :include, ClassAndInstanceMethods
-    base.send :prepend, Prepended.new
+
+    base.singleton_class.send :attr_accessor, :super_callbacks_prepended
+    base.super_callbacks_prepended = Prepended.new(base)
+    base.send :prepend, base.super_callbacks_prepended
+
+    # needed to fix bug while still support nested callbacks of which methods
+    # are defined in the subclasses
+    base.singleton_class.send :prepend, InheritancePrepender
+  end
+
+  module InheritancePrepender
+    def inherited(subclass)
+      # need to make a copy of the last SuperCallbacks::Prepended module in the ancestor chain
+      # and then `prepend` that module into the newly defined subclass
+      first_callbacks_prepended_module_instance = self.ancestors.detect { |ancestor| ancestor.is_a? SuperCallbacks::Prepended }
+
+      new_super_callbacks_prepended = Prepended.new(subclass)
+
+      subclass.singleton_class.send :attr_accessor, :super_callbacks_prepended
+      subclass.super_callbacks_prepended = new_super_callbacks_prepended
+
+      # ... which could be done via redefining the methods first...
+      (
+        first_callbacks_prepended_module_instance.instance_methods(false) +
+        first_callbacks_prepended_module_instance.private_instance_methods(false)
+      ).each do |method_name|
+        new_super_callbacks_prepended.send(:define_method, method_name) do |*args|
+          # this is the reason why this method needs to be redefined, and not just simply
+          # copied from the last SuperCallbacks::Prepended module;
+          # because the callback must only run once on the outermost prepended module
+          # for details, see spec 'runs the callbacks in correct order when the method is defined in the subclass'
+          return super(*args) if self.class.super_callbacks_prepended != subclass.super_callbacks_prepended
+
+          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
+
+      subclass.send :prepend, new_super_callbacks_prepended
+
+      copied_before_callbacks = Helpers.deep_array_and_hash_dup(first_callbacks_prepended_module_instance.base.before_callbacks)
+      copied_after_callbacks = Helpers.deep_array_and_hash_dup(first_callbacks_prepended_module_instance.base.after_callbacks)
+
+      subclass.instance_variable_set(:@before_callbacks, copied_before_callbacks)
+      subclass.instance_variable_set(:@after_callbacks, copied_after_callbacks)
+
+      # subclass.singleton_class.send :prepend, InheritancePrepender
+      super
+    end
   end
 
   private

data/lib/super_callbacks/class_and_instance_methods.rb

@@ -1,146 +1,150 @@
-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
+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]]
+
+      super_callbacks_prepended = self.super_callbacks_prepended
+
+      # dont redefine, to save cpu cycles
+      unless super_callbacks_prepended.instance_methods(false).include? method_name
+        super_callbacks_prepended.send(:define_method, method_name) do |*args|
+          return super(*args) if self.class.super_callbacks_prepended != super_callbacks_prepended
+
+          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]]
+
+      super_callbacks_prepended = self.super_callbacks_prepended
+
+      # dont redefine, to save cpu cycles
+      unless super_callbacks_prepended.instance_methods(false).include? method_name
+        super_callbacks_prepended.send(:define_method, method_name) do |*args|
+          return super(*args) if self.class.super_callbacks_prepended != super_callbacks_prepended
+
+          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 SuperCallbacks 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 SuperCallbacks 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 SuperCallbacks 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

@@ -1,10 +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
+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

@@ -1,23 +1,43 @@
-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
+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
+
+    def self.deep_array_and_hash_dup(enumerables, levels_left = nil)
+      return enumerables if levels_left && levels_left == 0
+
+      if enumerables.is_a?(Array)
+        enumerables = enumerables.dup
+        enumerables.each_with_index do |enumerable, index|
+          enumerables[index] = deep_array_and_hash_dup(enumerable, levels_left.nil? ? nil : levels_left - 1)
+        end
+        enumerables
+      elsif enumerables.is_a?(Hash)
+        enumerables = enumerables.dup
+        enumerables.each do |key, value|
+          enumerables[key] = deep_array_and_hash_dup(value, levels_left.nil? ? nil : levels_left - 1)
+        end
+        enumerables
+      else
+        enumerables
+      end
+    end
+  end
+end

data/lib/super_callbacks/instance_methods.rb

@@ -1,89 +1,71 @@
-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
+module SuperCallbacks
+  # The methods defined here will be available "class" methods for any class where SuperCallbacks is included
+  module InstanceMethods
+    def run_before_callbacks(method_name, *args)
+      class_before_callbacks = self.class.instance_variable_get(:@before_callbacks) || {}
+      instance_before_callbacks = instance_variable_get(:@before_callbacks) || {}
+
+      all_before_callbacks = SuperCallbacks::Helpers.deep_merge_hashes_and_combine_arrays(
+        class_before_callbacks,
+        instance_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
+
+    def run_after_callbacks(method_name, *args)
+      class_after_callbacks = self.class.instance_variable_get(:@after_callbacks) || {}
+      instance_after_callbacks = instance_variable_get(:@after_callbacks) || {}
+
+      all_after_callbacks = SuperCallbacks::Helpers.deep_merge_hashes_and_combine_arrays(
+        class_after_callbacks,
+        instance_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
+
+    def super_callbacks_prepended
+      _super_callbacks_prepended = self.singleton_class.ancestors.reverse.detect { |ancestor| ancestor.is_a? SuperCallbacks::Prepended }
+
+      if _super_callbacks_prepended.nil?
+        self.singleton_class.prepend SuperCallbacks::Prepended
+        _super_callbacks_prepended = self.singleton_class.ancestors.reverse.detect { |ancestor| ancestor.is_a? SuperCallbacks::Prepended }
+      end
+
+      _super_callbacks_prepended
+    end
+  end
+end

data/lib/super_callbacks/prepended.rb

@@ -1,9 +1,14 @@
-# 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
+# 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
+    attr_accessor :base
+
+    def initialize(base)
+      @base = base
+    end
+  end
+end

data/lib/super_callbacks/version.rb

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

data/super_callbacks.gemspec

@@ -1,29 +1,30 @@
-lib = File.expand_path('lib', __dir__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'super_callbacks/version'
-
-Gem::Specification.new do |spec|
-  spec.name          = 'super_callbacks'
-  spec.version       = SuperCallbacks::VERSION
-  spec.authors       = ['Jules Roman B. Polidario']
-  spec.email         = ['jules@topfloor.ie']
-
-  spec.summary       = 'Allows `before` and `after` callbacks to any Class. Supports dirty checking of instance variables changes, class and instance level callbacks, conditional callbacks, and inherited callbacks.'
-  spec.description   = 'Allows `before` and `after` callbacks to any Class. Supports dirty checking of instance variables changes, class and instance level callbacks, conditional callbacks, and inherited callbacks. Focuses on performance and flexibility as intended primarily for game development, and event-driven apps.'
-  spec.homepage      = 'https://github.com/jrpolidario/super_callbacks'
-  spec.license       = 'MIT'
-
-  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
-    f.match(%r{^(test|spec|features)/})
-  end
-  spec.bindir        = 'exe'
-  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
-  spec.require_paths = ['lib']
-
-  spec.required_ruby_version = '~> 2.0'
-
-  spec.add_development_dependency 'bundler', '~> 1.16'
-  spec.add_development_dependency 'rake', '~> 10.0'
-  spec.add_development_dependency 'rspec', '~> 3.0'
-  spec.add_development_dependency 'byebug', '~> 9.0'
-end
+lib = File.expand_path('lib', __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'super_callbacks/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'super_callbacks'
+  spec.version       = SuperCallbacks::VERSION
+  spec.authors       = ['Jules Roman B. Polidario']
+  spec.email         = ['jules@topfloor.ie']
+
+  spec.summary       = 'Allows `before` and `after` callbacks to any Class. Supports dirty checking of instance variables changes, class and instance level callbacks, conditional callbacks, and inherited callbacks.'
+  spec.description   = 'Allows `before` and `after` callbacks to any Class. Supports dirty checking of instance variables changes, class and instance level callbacks, conditional callbacks, and inherited callbacks. Focuses on performance and flexibility as intended primarily for game development, and event-driven apps.'
+  spec.homepage      = 'https://github.com/jrpolidario/super_callbacks'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.required_ruby_version = '~> 2.0'
+
+  spec.add_development_dependency 'bundler', '~> 1.16'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rspec', '~> 3.0'
+  spec.add_development_dependency 'pry', '~> 0.12.2'
+  spec.add_development_dependency 'pry-nav', '~> 0.3.0'
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: super_callbacks
 version: !ruby/object:Gem::Version
-  version: 1.2.0
+  version: 1.3.0
 platform: ruby
 authors:
 - Jules Roman B. Polidario
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-08-15 00:00:00.000000000 Z
+date: 2019-08-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -53,19 +53,33 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '3.0'
 - !ruby/object:Gem::Dependency
-  name: byebug
+  name: pry
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '9.0'
+        version: 0.12.2
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '9.0'
+        version: 0.12.2
+- !ruby/object:Gem::Dependency
+  name: pry-nav
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.3.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.3.0
 description: Allows `before` and `after` callbacks to any Class. Supports dirty checking
   of instance variables changes, class and instance level callbacks, conditional callbacks,
   and inherited callbacks. Focuses on performance and flexibility as intended primarily