easy_callbacks 0.1.2 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b09b4fff39b736c6bc599a4fb61b0e54d8c7f8dd
-  data.tar.gz: 250aa6be5312574c712c17d4a42275327f0a84ae
+  metadata.gz: b9ce7df274e4dff1affe27fa7d7b1bf71b6411c4
+  data.tar.gz: a55360bfebf3f88130a858cb48bfea028a5d5107
 SHA512:
-  metadata.gz: 808b9a22c807276a1fca19634eb5b7ad731f69a9e1538d5b63b712fec636092ea08934856dc5e66e09f0f2bbb1f842732f1533ab4de9a7d4dc8853530b2f84ce
-  data.tar.gz: 1fcad291d78710340a367b33557f57b8bb6bc5c5ca4921ca36c3aa9bd55a03be763acc2f4fa3cbc73b794f3ccae5f7b05caca599706da571943260c13dc4b80e
+  metadata.gz: d6a48def8a8b217b9425dd879766619b74214df262a9d70db9b802ebc1a6ea43574229fb28f8fb441419eed5a7739aa63200566ebe0367214f3327a0cd93acac
+  data.tar.gz: 6ff374249befe64bfb279dc2c0d18134ba3f2b55de961c25cdd2c992cc39807743bcd30e12255486c0d409cb37e4e0a003b25134653fbda4a15571d34fd2f1c9

data/README.rdoc

@@ -1,115 +1,144 @@
 = Easy Callbacks
 
-Provide callbacks support for Ruby classes.
+Provides callback support for Ruby classes.
 
 == Example
 
+For a given class:
+
     class SomeClass
 
-        def some_method(some_arg)
-            puts some_arg
-        end
+      def some_method(some_arg)
+        puts "some_method: #{some_arg}"
+      end
 
-        include EasyCallbacks::Base
+      def before_some_method(some_arg)
+        puts "before_some_method: #{some_arg}"
+      end
 
-        # named callbacks
-        before :some_method, :do_it_before
-        around :some_method, :do_it_around
-        after :some_method, :do_it_after
+      def around_some_method(some_arg)
+        puts "around_some_method: #{some_arg}"
+      end
 
-        # anonymous callbacks
-        before :some_method do |some_arg, callback_details|
-            # ...
-        end
+    end
 
-        def do_it_before(some_arg, callback_details)
-            # ...
-        end
+    EasyCallbacks.configure(SomeClass) do
 
-        def do_it_around(some_arg, callback_details)
-            # ...
-        end
+      # named callback
+      before :some_method, :before_some_method
 
-        def do_it_after(some_arg, callback_details)
-            # ...
-        end
+      # named callback
+      around :some_method, :around_some_method
+
+      # anonymous callback
+      after  :some_method do
+        puts "after_some_method: #{call_args[0]}"
+      end
 
     end
 
-=== Callback Details
+This call:
 
-The second argument is a Hash containing some callback call details:
+    SomeClass.new.some_method :some_arg
 
-For named callbacks:
+Produces this output:
 
-    {
-        class: SomeClass,
-        target: :some_method,
-        type: :before,
-        callback_name: :do_it_before,
-        proc: nil
-    }
+    before_some_method: hue
+    some_method: hue
+    around_some_method: hue
+    after_some_method: hue
 
-For anonymous callbacks:
+== Helper Methods
 
-    {
-        class: SomeClass,
-        object: #<SomeClass:0x00000002b65ab0>,
-        target: :some_method,
-        type: :before,
-        callback_name: nil,
-        proc: #<Proc:0x00000002655a20@...>
-    }
+Inside a callback block/method, you can call three helper methods:
 
-For around callbacks (with success):
+    call_args        # returns original arguments given to the call
+    call_block       # returns original block given to the call
+    callback_details # returns details of callback execution
 
-    {
-        class: SomeClass,
-        target: :some_method,
-        type: :around,
-        callback_name: :do_it_around,
-        proc: nil,
-        return_type: :success,
-        return_object: nil
-    }
+=== Callback Details
 
-For around callbacks (with error):
+The `callback_details` helper method will return:
 
     {
-        class: SomeClass,
-        target: :some_method,
-        type: :around,
-        callback_name: :do_it_around,
-        proc: nil,
-        return_type: :error,
-        return_object: #<StandardError: StandardError>
+        target_class: SomeClass,
+        callback_type: :around,
+        target_method_name: :some_method,
+        callback_method_name: :around_some_method,
+        callback_block: nil,
+        return_type: :success, # exclusive for `around` callbacks
+        return_object: nil     # exclusive for `around` callbacks
     }
 
+== Module inclusion
+
+You can call `before`, `around` and `after` methods directly instead of calling them inside of `EasyCallbacks.configure` block. Just include `EasyCallbacks` module:
+
+    class SomeClass
+
+      def some_method(some_arg)
+        puts "some_method: #{some_arg}"
+      end
+
+      def before_some_method(some_arg)
+        puts "before_some_method: #{some_arg}"
+      end
+
+      def around_some_method(some_arg)
+        puts "around_some_method: #{some_arg}"
+      end
+
+      include EasyCallbacks
+
+      before :some_method, :before_some_method
+
+      around :some_method, :around_some_method
+
+      after  :some_method do
+        puts "after_some_method: #{call_args[0]}"
+      end
+
+    end
+
 == Singleton Classes Support
 
 It works too:
 
     class SomeClass
 
-        class << self
+      class << self
 
-            def some_method(some_arg)
-                puts some_arg
-            end
+        def some_method(some_arg)
+          puts "some_method: #{some_arg}"
+        end
 
-            include EasyCallbacks::Base
+        def before_some_method(some_arg)
+          puts "before_some_method: #{some_arg}"
+        end
 
-            # ...
+        def around_some_method(some_arg)
+          puts "around_some_method: #{some_arg}"
+        end
 
+        include EasyCallbacks
+
+        before :some_method, :before_some_method
+
+        around :some_method, :around_some_method
+
+        after  :some_method do
+          puts "after_some_method: #{call_args[0]}"
         end
 
+      end
+
     end
 
-    SomeClass.some_method 'some arg'
+    SomeClass.some_method :hue
 
-== Changelog
+== More
 
-See 'changelog.txt' to follow the progress.
+To see more of `EasyCallbacks` usages, please take a look at DummyClass[https://github.com/r4z3c/easy_callbacks/blob/master/spec/support/dummy_class.rb].
 
 ===
 

data/easy_callbacks.gemspec

@@ -19,9 +19,10 @@ Gem::Specification.new do |s|
 
   s.add_dependency 'bundler', '~>1'
   s.add_dependency 'activesupport', '~>4'
-  s.add_dependency 'method_decorator', '~>1'
+  s.add_dependency 'method_decorator', '~>3.0.1'
 
   s.add_development_dependency 'rspec', '~>3'
   s.add_development_dependency 'simplecov', '~>0'
   s.add_development_dependency 'model-builder', '~>2'
+  s.add_development_dependency 'rake'
 end

data/lib/easy_callbacks/all.rb

@@ -0,0 +1,8 @@
+require 'easy_callbacks/models/target_class'
+require 'easy_callbacks/models/callback'
+require 'easy_callbacks/repositories/base_repository'
+require 'easy_callbacks/repositories/target_classes_repository'
+require 'easy_callbacks/repositories/callbacks_repository'
+require 'easy_callbacks/dsls/target_classes_dsl'
+require 'easy_callbacks/utils/validator'
+require 'easy_callbacks/utils/serializer'

data/lib/easy_callbacks/dsls/target_classes_dsl.rb

@@ -0,0 +1,77 @@
+require 'method_decorator'
+
+module EasyCallbacks
+  module Dsls
+
+    class TargetClassesDsl
+
+      attr_accessor :target_class_instance
+
+      def initialize(target_class_instance)
+        self.target_class_instance = target_class_instance
+      end
+
+      def before(target_method_name, callback_method_name=nil, &callback_block)
+        handle_callback_definition :before, target_method_name, callback_method_name, &callback_block
+      end
+
+      def around(target_method_name, callback_method_name=nil, &callback_block)
+        handle_callback_definition :around, target_method_name, callback_method_name, &callback_block
+      end
+
+      def after(target_method_name, callback_method_name=nil, &callback_block)
+        handle_callback_definition :after, target_method_name, callback_method_name, &callback_block
+      end
+
+      protected
+
+      def handle_callback_definition(callback_type, target_method_name, callback_method_name, &callback_block)
+        push_callback callback_type, target_method_name, callback_method_name, &callback_block
+        decorate_method target_method_name
+      end
+
+      def push_callback(callback_type, target_method_name, callback_method_name, &callback_block)
+        target_class_instance.add_callback callback_type, target_method_name, callback_method_name, &callback_block
+      end
+
+      def decorate_method(target_method_name)
+        tci = target_class_instance
+        MethodDecorator.decorate target_class_instance.target_class, target_method_name do
+          EasyCallbacks.execute_callbacks self, tci, :before, target_method_name, nil, call_args, &call_block
+
+          result = error = nil
+          begin
+            result = call_original
+          rescue => e
+            error = e
+          end
+
+          additional_options = error ?
+            { return_type: :error, return_object: error } :
+            { return_type: :success, return_object: result }
+
+          EasyCallbacks.execute_callbacks self, tci, :around, target_method_name, additional_options, call_args, &call_block
+
+          raise error if error
+
+          EasyCallbacks.execute_callbacks self, tci, :after, target_method_name, nil, call_args, &call_block
+
+          result
+        end
+      end
+
+      def target_class_instance=(target_class_instance)
+        validate_target_class_instance target_class_instance
+        @target_class_instance = target_class_instance
+      end
+
+      def validate_target_class_instance(target_class_instance)
+        Utils::Validator.validate_instance_type! :target_class_instance,
+                                                target_class_instance,
+                                                Models::TargetClass
+      end
+
+    end
+
+  end
+end

data/lib/easy_callbacks/models/callback.rb

@@ -0,0 +1,18 @@
+module EasyCallbacks
+  module Models
+
+    class Callback
+
+      attr_accessor :callback_type, :target_method_name, :callback_method_name, :callback_block
+
+      def initialize(callback_type, target_method_name, callback_method_name)
+        self.callback_type = callback_type
+        self.target_method_name = target_method_name
+        self.callback_method_name = callback_method_name
+        self.callback_block = block_given? ? Proc.new : nil
+      end
+
+    end
+
+  end
+end

data/lib/easy_callbacks/models/target_class.rb

@@ -0,0 +1,35 @@
+module EasyCallbacks
+  module Models
+
+    class TargetClass
+
+      attr_accessor :target_class, :callbacks_repository
+
+      def initialize(target_class)
+        self.target_class = target_class
+        self.callbacks_repository = ::EasyCallbacks::Repositories::CallbacksRepository.new self
+      end
+
+      def add_callback(callback_type, target_method_name, callback_method_name, &callback_block)
+        callbacks_repository.find_or_add callback_type, target_method_name, callback_method_name, &callback_block
+      end
+
+      def get_callbacks_for(callback_type, target_method_name)
+        callbacks_repository.get_callbacks_for callback_type, target_method_name
+      end
+
+      protected
+
+      def target_class=(target_class)
+        validate_target_class target_class
+        @target_class = target_class
+      end
+
+      def validate_target_class(target_class)
+        Utils::Validator.validate_instance_type! :target_class, target_class, Class
+      end
+
+    end
+
+  end
+end

data/lib/easy_callbacks/repositories/base_repository.rb

@@ -0,0 +1,37 @@
+module EasyCallbacks
+  module Repositories
+
+    class BaseRepository
+
+      attr_accessor :list
+
+      def initialize(*args); self.list = [] end
+
+      def find_or_add(*args, &block); find(*args) || add(*args, &block) end
+
+      def add(*args, &block)
+        unless exists? *args
+          model_instance = block_given? ? model.new(*args, &block) : model.new(*args)
+          self.list.push(model_instance)
+          model_instance
+        end
+      end
+
+      def exists?(*args); not find(*args).nil? end
+
+      def find(*args); list.find &find_block(*args) end
+
+      protected
+
+      def find_block(*args)
+        raise NotImplementedError.new("find_block@#{self.class} must overwrite find_block@#{self.class.superclass}")
+      end
+
+      def model
+        raise NotImplementedError.new("model@#{self.class} must overwrite model@#{self.class.superclass}")
+      end
+
+    end
+
+  end
+end

data/lib/easy_callbacks/repositories/callbacks_repository.rb

@@ -0,0 +1,44 @@
+module EasyCallbacks
+  module Repositories
+
+    class CallbacksRepository < BaseRepository
+
+      attr_accessor :target_class_instance
+
+      def initialize(target_class_instance)
+        super
+        self.target_class_instance = target_class_instance
+      end
+
+      def get_callbacks_for(callback_type, target_method_name)
+        list.select do |c|
+          c.callback_type.eql?(callback_type) and
+          c.target_method_name.eql?(target_method_name)
+        end
+      end
+
+      protected
+
+      def find_block(callback_type, target_method_name, callback_method_name)
+        Proc.new do |item|
+          item.callback_type.eql? callback_type and
+          item.target_method_name.eql? target_method_name and
+          item.callback_method_name.eql? callback_method_name
+        end
+      end
+
+      def model; Models::Callback end
+
+      def target_class_instance=(target_class_instance)
+        validate_target_class_instance target_class_instance
+        @target_class_instance = target_class_instance
+      end
+
+      def validate_target_class_instance(target_class_instance)
+        Utils::Validator.validate_instance_type! :target_class_instance, target_class_instance, Models::TargetClass
+      end
+
+    end
+
+  end
+end

data/lib/easy_callbacks/repositories/target_classes_repository.rb

@@ -0,0 +1,15 @@
+module EasyCallbacks
+  module Repositories
+
+    class TargetClassesRepository < BaseRepository
+
+      protected
+
+      def find_block(target_class); Proc.new { |item| item.target_class.eql? target_class } end
+
+      def model; Models::TargetClass end
+
+    end
+
+  end
+end

data/lib/easy_callbacks/utils/serializer.rb

@@ -0,0 +1,20 @@
+module EasyCallbacks
+  module Utils
+
+    class Serializer
+
+      class << self
+
+        def to_h(object, attrs=[])
+          attrs = [attrs] unless attrs.is_a? Array
+          hash = {}
+          attrs.each { |k| hash[k.to_sym] = object.send k }
+          hash
+        end
+
+      end
+
+    end
+
+  end
+end

data/lib/easy_callbacks/utils/validator.rb

@@ -0,0 +1,17 @@
+module EasyCallbacks
+  module Utils
+
+    class Validator
+
+      class << self
+
+        def validate_instance_type!(attribute_name, instance, desired_type)
+          raise TypeError.new("#{attribute_name} must be a #{desired_type}") unless instance.is_a? desired_type
+        end
+
+      end
+
+    end
+
+  end
+end

data/lib/easy_callbacks/version.rb

@@ -1,3 +1,3 @@
 module EasyCallbacks
-  VERSION = '0.1.2'
+  VERSION = '1.0.0'
 end

data/lib/easy_callbacks.rb

@@ -1,17 +1,69 @@
-module EasyCallbacks
+require 'easy_callbacks/all'
+require 'active_support/concern'
 
-  ROOT = File.expand_path(File.join(File.dirname(__FILE__),'..'))
+module EasyCallbacks extend ActiveSupport::Concern
 
-  class << self
+  included do
+
+    class << self
+
+      def before(target_method_name, callback_method_name=nil, &callback_block)
+        handle_callback_definition :before, target_method_name, callback_method_name, &callback_block
+      end
 
-    def load_easy_callbacks
-      Dir[File.expand_path(File.join(ROOT,'lib','easy_callbacks','**/*.rb'))].each do |file|
-        require file
+      def around(target_method_name, callback_method_name=nil, &callback_block)
+        handle_callback_definition :around, target_method_name, callback_method_name, &callback_block
       end
+
+      def after(target_method_name, callback_method_name=nil, &callback_block)
+        handle_callback_definition :after, target_method_name, callback_method_name, &callback_block
+      end
+
+      def handle_callback_definition(callback_type, target_method_name, callback_method_name, &callback_block)
+        EasyCallbacks.configure(self) { send callback_type, target_method_name, callback_method_name, &callback_block }
+      end
+
     end
 
   end
 
-  load_easy_callbacks
+  class << self
+
+    attr_writer :target_classes_repository
+
+    def configure(target_class, &cfg_block)
+      target_class_instance = target_classes_repository.find_or_add target_class
+      Dsls::TargetClassesDsl.new(target_class_instance).instance_eval &cfg_block
+    end
+
+    def execute_callbacks(context, target_class_instance, callback_type, target_method_name, additional_options, call_args, &call_block)
+      validate_target_class_instance target_class_instance
+      target_class_instance.get_callbacks_for(callback_type, target_method_name).each do |callback|
+        define_callback_details_method additional_options, callback, target_class_instance
+        proc = callback.callback_block
+        proc.nil? ? context.send(callback.callback_method_name, *call_args, &call_block) : context.instance_eval(&proc)
+      end
+    end
+
+    def define_callback_details_method(additional_options, callback, target_class_instance)
+      target_class_instance.target_class.send :define_method, :callback_details do
+        callback_details = Utils::Serializer.to_h(
+          callback, %w(callback_type target_method_name callback_method_name callback_block)
+        ).merge(target_class: target_class_instance.target_class)
+        additional_options ? callback_details.merge(additional_options) : callback_details
+      end
+    end
+
+    protected
+
+    def validate_target_class_instance(target_class_instance)
+      Utils::Validator.validate_instance_type! :target_class_instance, target_class_instance, Models::TargetClass
+    end
+
+    def target_classes_repository
+      @target_classes_repository ||= Repositories::TargetClassesRepository.new
+    end
+
+  end
 
 end

data/spec/lib/easy_callbacks_spec.rb

@@ -0,0 +1,187 @@
+require 'spec_helper'
+require 'support/dummy_class'
+
+describe EasyCallbacks do
+
+  let(:dummy_arg) { :dummy_arg }
+
+  context 'when common class as target' do
+
+    let(:target) { DummyClass }
+    let(:target_instance) { target.new }
+
+    context 'when public method' do
+
+      context 'when through module singleton method' do
+
+        before do
+          expect(target_instance).to receive(:puts).with("before_a_public_instance_method_with: #{[dummy_arg]}").ordered
+          expect(target_instance).to receive(:puts).with("a_public_instance_method_arg: #{dummy_arg}").ordered
+          expect(target_instance).to receive(:puts).with("around_a_public_instance_method_with: #{[dummy_arg]}").ordered
+          expect(target_instance).to receive(:puts).with("after_a_public_instance_method_with: #{[dummy_arg]}").ordered
+        end
+
+        it { target_instance.a_public_instance_method dummy_arg }
+
+      end
+
+      context 'when through module inclusion' do
+
+        before do
+          expect(target_instance).to receive(:puts).with("before_another_public_instance_method_with: #{[dummy_arg]}").ordered
+          expect(target_instance).to receive(:puts).with("another_public_instance_method_arg: #{dummy_arg}").ordered
+          expect(target_instance).to receive(:puts).with("around_another_public_instance_method_with: #{[dummy_arg]}").ordered
+          expect(target_instance).to receive(:puts).with("after_another_public_instance_method_with: #{[dummy_arg]}").ordered
+        end
+
+        it { target_instance.another_public_instance_method dummy_arg }
+
+      end
+
+    end
+
+    context 'when protected method' do
+
+      context 'when calling protected method deliberately' do
+
+        it { expect{target_instance.a_protected_instance_method dummy_arg}.to raise_error NoMethodError }
+
+      end
+
+      context 'when calling protected method through `send`' do
+
+        before do
+          expect(target_instance).to receive(:puts).with("before_a_protected_instance_method_with: #{[dummy_arg]}").ordered
+          expect(target_instance).to receive(:puts).with("a_protected_instance_method_arg: #{dummy_arg}").ordered
+          expect(target_instance).to receive(:puts).with("around_a_protected_instance_method_with: #{[dummy_arg]}").ordered
+          expect(target_instance).to receive(:puts).with("after_a_protected_instance_method_with: #{[dummy_arg]}").ordered
+        end
+
+        it { target_instance.send :a_protected_instance_method, dummy_arg }
+
+      end
+
+    end
+
+    context 'when private method' do
+
+      context 'when calling private method deliberately' do
+
+        it { expect{target_instance.a_private_instance_method dummy_arg}.to raise_error NoMethodError }
+
+      end
+
+      context 'when calling private method through `send`' do
+
+        before do
+          expect(target_instance).to receive(:puts).with("before_a_private_instance_method_with: #{[dummy_arg]}").ordered
+          expect(target_instance).to receive(:puts).with("a_private_instance_method_arg: #{dummy_arg}").ordered
+          expect(target_instance).to receive(:puts).with("around_a_private_instance_method_with: #{[dummy_arg]}").ordered
+          expect(target_instance).to receive(:puts).with("after_a_private_instance_method_with: #{[dummy_arg]}").ordered
+        end
+
+        it { target_instance.send :a_private_instance_method, dummy_arg }
+
+      end
+
+    end
+
+    context 'when dealing with around callback error' do
+
+      let(:error_msg) { 'some runtime error' }
+
+      before do
+        expect(target_instance).to receive(:puts).with("a_public_instance_method_with_error_arg: #{dummy_arg}").ordered
+        expect(target_instance).to receive(:puts).with("around_a_public_instance_method_with_error: #{error_msg}").ordered
+      end
+
+      it { expect{target_instance.a_public_instance_method_with_error dummy_arg}.to raise_error(RuntimeError, error_msg) }
+
+    end
+
+  end
+
+  context 'when singleton class as target' do
+
+    let(:target) { DummyClass.singleton_class }
+    let(:target_instance) { DummyClass }
+
+    context 'when public method' do
+
+      context 'when through module singleton method' do
+
+        before do
+          expect(target_instance).to receive(:puts).with("before_a_public_singleton_method_with: #{[dummy_arg]}").ordered
+          expect(target_instance).to receive(:puts).with("a_public_singleton_method_arg: #{dummy_arg}").ordered
+          expect(target_instance).to receive(:puts).with("around_a_public_singleton_method_with: #{[dummy_arg]}").ordered
+          expect(target_instance).to receive(:puts).with("after_a_public_singleton_method_with: #{[dummy_arg]}").ordered
+        end
+
+        it { target_instance.a_public_singleton_method dummy_arg }
+
+      end
+
+      context 'when through module inclusion' do
+
+        before do
+          expect(target_instance).to receive(:puts).with("before_another_public_singleton_method_with: #{[dummy_arg]}").ordered
+          expect(target_instance).to receive(:puts).with("another_public_singleton_method_arg: #{dummy_arg}").ordered
+          expect(target_instance).to receive(:puts).with("around_another_public_singleton_method_with: #{[dummy_arg]}").ordered
+          expect(target_instance).to receive(:puts).with("after_another_public_singleton_method_with: #{[dummy_arg]}").ordered
+        end
+
+        it { target_instance.another_public_singleton_method dummy_arg }
+
+      end
+
+    end
+
+    context 'when protected method' do
+
+      context 'when calling protected method deliberately' do
+
+        it { expect{target_instance.a_protected_singleton_method dummy_arg}.to raise_error NoMethodError }
+
+      end
+
+      context 'when calling protected method through `send`' do
+
+        before do
+          expect(target_instance).to receive(:puts).with("before_a_protected_singleton_method_with: #{[dummy_arg]}").ordered
+          expect(target_instance).to receive(:puts).with("a_protected_singleton_method_arg: #{dummy_arg}").ordered
+          expect(target_instance).to receive(:puts).with("around_a_protected_singleton_method_with: #{[dummy_arg]}").ordered
+          expect(target_instance).to receive(:puts).with("after_a_protected_singleton_method_with: #{[dummy_arg]}").ordered
+        end
+
+        it { target_instance.send :a_protected_singleton_method, dummy_arg }
+
+      end
+
+    end
+
+    context 'when private method' do
+
+      context 'when calling private method deliberately' do
+
+        it { expect{target_instance.a_private_singleton_method dummy_arg}.to raise_error NoMethodError }
+
+      end
+
+      context 'when calling private method through `send`' do
+
+        before do
+          expect(target_instance).to receive(:puts).with("before_a_private_singleton_method_with: #{[dummy_arg]}").ordered
+          expect(target_instance).to receive(:puts).with("a_private_singleton_method_arg: #{dummy_arg}").ordered
+          expect(target_instance).to receive(:puts).with("around_a_private_singleton_method_with: #{[dummy_arg]}").ordered
+          expect(target_instance).to receive(:puts).with("after_a_private_singleton_method_with: #{[dummy_arg]}").ordered
+        end
+
+        it { target_instance.send :a_private_singleton_method, dummy_arg }
+
+      end
+
+    end
+
+  end
+
+end

data/spec/lib/repositories/base_repository_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+base_repository = EasyCallbacks::Repositories::BaseRepository
+
+describe base_repository do
+
+  it 'must override base repository `find_block` method' do
+    expect{base_repository.new.send :find_block }.to raise_error(NotImplementedError)
+  end
+
+  it 'must override base repository `model` method' do
+    expect{base_repository.new.send :model }.to raise_error(NotImplementedError)
+  end
+
+end

data/spec/support/dummy_class.rb

@@ -0,0 +1,160 @@
+class DummyClass
+
+  def a_public_instance_method(arg)
+    puts "a_public_instance_method_arg: #{arg}"
+  end
+
+  def another_public_instance_method(arg)
+    puts "another_public_instance_method_arg: #{arg}"
+  end
+
+  def a_public_instance_method_with_error(arg)
+    puts "a_public_instance_method_with_error_arg: #{arg}"
+    raise 'some runtime error'
+  end
+
+  protected
+
+  def a_protected_instance_method(arg)
+    puts "a_protected_instance_method_arg: #{arg}"
+  end
+
+  private
+
+  def a_private_instance_method(arg)
+    puts "a_private_instance_method_arg: #{arg}"
+  end
+
+  class << self
+
+    def a_public_singleton_method(arg)
+      puts "a_public_singleton_method_arg: #{arg}"
+    end
+
+    def another_public_singleton_method(arg)
+      puts "another_public_singleton_method_arg: #{arg}"
+    end
+
+    protected
+
+    def a_protected_singleton_method(arg)
+      puts "a_protected_singleton_method_arg: #{arg}"
+    end
+
+    private
+
+    def a_private_singleton_method(arg)
+      puts "a_private_singleton_method_arg: #{arg}"
+    end
+
+    include EasyCallbacks
+
+    before :another_public_singleton_method do
+      puts "before_another_public_singleton_method_with: #{call_args}"
+    end
+
+    around :another_public_singleton_method do
+      puts "around_another_public_singleton_method_with: #{call_args}"
+    end
+
+    after :another_public_singleton_method do
+      puts "after_another_public_singleton_method_with: #{call_args}"
+    end
+
+  end
+
+  include EasyCallbacks
+
+  before :another_public_instance_method do
+    puts "before_another_public_instance_method_with: #{call_args}"
+  end
+
+  around :another_public_instance_method do
+    puts "around_another_public_instance_method_with: #{call_args}"
+  end
+
+  after :another_public_instance_method do
+    puts "after_another_public_instance_method_with: #{call_args}"
+  end
+
+end
+
+EasyCallbacks.configure(DummyClass) do
+  before :a_public_instance_method do
+    puts "before_a_public_instance_method_with: #{call_args}"
+  end
+
+  around :a_public_instance_method do
+    puts "around_a_public_instance_method_with: #{call_args}"
+  end
+
+  after :a_public_instance_method do
+    puts "after_a_public_instance_method_with: #{call_args}"
+  end
+
+  before :a_protected_instance_method do
+    puts "before_a_protected_instance_method_with: #{call_args}"
+  end
+
+  around :a_protected_instance_method do
+    puts "around_a_protected_instance_method_with: #{call_args}"
+  end
+
+  after :a_protected_instance_method do
+    puts "after_a_protected_instance_method_with: #{call_args}"
+  end
+
+  before :a_private_instance_method do
+    puts "before_a_private_instance_method_with: #{call_args}"
+  end
+
+  around :a_private_instance_method do
+    puts "around_a_private_instance_method_with: #{call_args}"
+  end
+
+  after :a_private_instance_method do
+    puts "after_a_private_instance_method_with: #{call_args}"
+  end
+
+  around :a_public_instance_method_with_error do
+    puts "around_a_public_instance_method_with_error: #{callback_details[:return_object]}"
+  end
+end
+
+EasyCallbacks.configure(DummyClass.singleton_class) do
+  before :a_public_singleton_method do
+    puts "before_a_public_singleton_method_with: #{call_args}"
+  end
+
+  around :a_public_singleton_method do
+    puts "around_a_public_singleton_method_with: #{call_args}"
+  end
+
+  after :a_public_singleton_method do
+    puts "after_a_public_singleton_method_with: #{call_args}"
+  end
+
+  before :a_protected_singleton_method do
+    puts "before_a_protected_singleton_method_with: #{call_args}"
+  end
+
+  around :a_protected_singleton_method do
+    puts "around_a_protected_singleton_method_with: #{call_args}"
+  end
+
+  after :a_protected_singleton_method do
+    puts "after_a_protected_singleton_method_with: #{call_args}"
+  end
+
+  before :a_private_singleton_method do
+    puts "before_a_private_singleton_method_with: #{call_args}"
+  end
+
+  around :a_private_singleton_method do
+    puts "around_a_private_singleton_method_with: #{call_args}"
+  end
+
+  after :a_private_singleton_method do
+    puts "after_a_private_singleton_method_with: #{call_args}"
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: easy_callbacks
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 1.0.0
 platform: ruby
 authors:
 - r4z3c
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-06-24 00:00:00.000000000 Z
+date: 2017-03-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -44,14 +44,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1'
+        version: 3.0.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1'
+        version: 3.0.1
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -94,6 +94,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2'
+- !ruby/object:Gem::Dependency
+  name: rake
+  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'
 description: Provide callbacks support for Ruby classes
 email:
 - r4z3c.43@gmail.com
@@ -107,14 +121,22 @@ files:
 - MIT-LICENSE
 - README.rdoc
 - Rakefile
-- changelog.txt
 - easy_callbacks.gemspec
 - lib/easy_callbacks.rb
-- lib/easy_callbacks/base.rb
+- lib/easy_callbacks/all.rb
+- lib/easy_callbacks/dsls/target_classes_dsl.rb
+- lib/easy_callbacks/models/callback.rb
+- lib/easy_callbacks/models/target_class.rb
+- lib/easy_callbacks/repositories/base_repository.rb
+- lib/easy_callbacks/repositories/callbacks_repository.rb
+- lib/easy_callbacks/repositories/target_classes_repository.rb
+- lib/easy_callbacks/utils/serializer.rb
+- lib/easy_callbacks/utils/validator.rb
 - lib/easy_callbacks/version.rb
-- spec/lib/easy_callbacks/base_spec.rb
+- spec/lib/easy_callbacks_spec.rb
+- spec/lib/repositories/base_repository_spec.rb
 - spec/spec_helper.rb
-- spec/support/some_class.rb
+- spec/support/dummy_class.rb
 homepage: https://github.com/r4z3c/easy_callbacks.git
 licenses:
 - MIT
@@ -140,6 +162,7 @@ signing_key:
 specification_version: 4
 summary: Set callbacks for Ruby class methods
 test_files:
-- spec/lib/easy_callbacks/base_spec.rb
+- spec/lib/easy_callbacks_spec.rb
+- spec/lib/repositories/base_repository_spec.rb
 - spec/spec_helper.rb
-- spec/support/some_class.rb
+- spec/support/dummy_class.rb

data/changelog.txt

@@ -1,13 +0,0 @@
-# 0.1.2
-
-- setting 'execute_callbacks_for' (and related methods) as private
-
-# 0.1.1
-
-- fixing callbacks initialization bug: when trying to 'execute_callbacks_for' for a type (e.g. 'before') that doesn't
-  received pushes, it crashes by trying call 'select' to a nil object
-
-# 0.1.0
-
-- adding 'object' key to 'callback_details' providing context to anonymous callbacks
-- removing 'method_missing' strategy from base module, this isn't strictly necessary

data/lib/easy_callbacks/base.rb

@@ -1,117 +0,0 @@
-require 'method_decorator'
-
-module EasyCallbacks
-  module Base extend ActiveSupport::Concern
-
-    included do
-
-      include MethodDecorator
-
-      class << self
-
-        attr_accessor :callbacks
-
-        def before(target, callback_name=nil, &block)
-          handle_callback_definition :before, target, callback_name, &block
-        end
-
-        def around(target, callback_name=nil, &block)
-          handle_callback_definition :around, target, callback_name, &block
-        end
-
-        def after(target, callback_name=nil, &block)
-          handle_callback_definition :after, target, callback_name, &block
-        end
-
-        private
-
-        def handle_callback_definition(type, target, callback_name, &block)
-          push_callback type, target, callback_name, &block
-          decorate_target target
-        end
-
-        def push_callback(type, target, callback_name)
-          initialize_callbacks
-          self.callbacks[type].push target: target,
-                                    callback_name: callback_name,
-                                    proc: (block_given? ? Proc.new : nil)
-        end
-
-        def initialize_callbacks
-          self.callbacks ||= {}
-          self.callbacks[:before] ||= []
-          self.callbacks[:around] ||= []
-          self.callbacks[:after] ||= []
-        end
-
-        def decorate_target(target)
-          decorate_method target do |*args, &block|
-            execute_callbacks_for :before, target, nil, *args, &block
-            result, error = execute_original_method target, *args, &block
-
-            additional_options = error ?
-              { return_type: :error, return_object: error } :
-              { return_type: :success, return_object: result }
-
-            execute_callbacks_for :around, target, additional_options, *args, &block
-
-            raise error if error
-
-            execute_callbacks_for :after, target, nil, *args, &block
-
-            result
-          end unless method_defined? original_method_name_for(target)
-        end
-
-      end
-
-      private
-
-      def execute_callbacks_for(type, target, additional_options, *args, &block)
-        get_callbacks_for(type).select { |c| c[:target].eql? target }.each do |callback|
-          cn = callback[:callback_name]
-          proc = callback[:proc]
-          t = callback[:target]
-          arguments = args + [
-              class: callbacks_holder,
-              target: t,
-              type: type,
-              callback_name: cn,
-              proc: proc
-          ];
-
-          arguments.last.merge! additional_options if additional_options
-
-          if proc.nil?
-            send(cn, *arguments, &block)
-          else
-            arguments.last.merge! object: self
-            proc.call(*arguments, &block)
-          end
-        end
-      end
-
-      def get_callbacks_for(type)
-        callbacks_holder.callbacks[type]
-      end
-
-      def callbacks_holder
-        self.class.eql?(Class) ? self.singleton_class : self.class
-      end
-
-      def execute_original_method(target, *args, &block)
-        result = error = nil
-
-        begin
-          result = call_original_method target, *args, &block
-        rescue => e
-          error = e
-        end
-
-        return result, error
-      end
-
-    end
-
-  end
-end

data/spec/lib/easy_callbacks/base_spec.rb

@@ -1,28 +0,0 @@
-require 'spec_helper'
-require 'support/some_class'
-
-describe EasyCallbacks::Base do
-
-  let(:instance) { SomeClass.new }
-
-  it do
-    expect_instance_for_puts_with('before_1: some_arg')
-    expect_class_for_puts_with('before_2: some_arg')
-    expect_instance_for_puts_with('some_method: some_arg')
-    expect_instance_for_puts_with('around_1: some_arg')
-    expect_class_for_puts_with('around_2: some_arg')
-    expect_instance_for_puts_with('after_1: some_arg')
-    expect_class_for_puts_with('after_2: some_arg')
-
-    instance.some_method(:some_arg)
-  end
-
-  def expect_instance_for_puts_with(expected)
-    expect(instance).to receive(:puts).with(expected).ordered
-  end
-
-  def expect_class_for_puts_with(expected)
-    expect(SomeClass).to receive(:puts).with(expected).ordered
-  end
-
-end

data/spec/support/some_class.rb

@@ -1,36 +0,0 @@
-class SomeClass
-
-  def some_method(some_arg)
-    puts "some_method: #{some_arg}"
-  end
-
-  include EasyCallbacks::Base
-
-  before :some_method, :before_1
-  before :some_method do |some_arg, callback_details|
-    puts "before_2: #{some_arg}"
-  end
-
-  around :some_method, :around_1
-  around :some_method do |some_arg, callback_details|
-    puts "around_2: #{some_arg}"
-  end
-
-  after :some_method, :after_1
-  after :some_method do |some_arg, callback_details|
-    puts "after_2: #{some_arg}"
-  end
-
-  def before_1(some_arg, callback_details)
-    puts "before_1: #{some_arg}"
-  end
-
-  def around_1(some_arg, callback_details)
-    puts "around_1: #{some_arg}"
-  end
-
-  def after_1(some_arg, callback_details)
-    puts "after_1: #{some_arg}"
-  end
-
-end