method_decorator 3.0.2 → 4.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9db54a7da140b414c3e9ab1d1c922b1f9fadf9c0
-  data.tar.gz: 61af7d43a268354cb151b6c461bd41467b352b21
+  metadata.gz: 24035e46f4f4e95da3c06a525d08c07cb0652541
+  data.tar.gz: 7671f1cfe76a192254cf902a8373e7a33fc6619f
 SHA512:
-  metadata.gz: 2635c19dda2211e44cfbb1b3920af969e68e36d2c31b5091fe119aaefd37453e67b9b2d28a6abc848638b76400a117c737b8fbaadd1b6dd4685f268aee0be420
-  data.tar.gz: 519499c0731fffb1fdfd2fdd2f03d70ebcd0e917c9544ad1b4a7c9a4fbd524f9169f3038e4f32f89077547c26b3e810265fcf8a4de847b8b718de670cfb676b4
+  metadata.gz: ef0319cef3a7d8645a849b744b44bbb36cbd61bafdc343aa87a7a39c2e2674f6ae7d115f0dd8b7610389cead5e23ee0547681e3ee5498d74839232da3dc7ba0b
+  data.tar.gz: ebed4eae693f0f1a52c9d5dcd7f765735bf1e42b044fbb0a67378b191248a39cf81f0b119a7d74a4b133a335b37a48cd40b2010ec8105f157cfbf046b3d59f07

data/.rubocop.yml

@@ -0,0 +1,24 @@
+Documentation:
+  Enabled: false
+
+Style/PredicateName:
+  Enabled: false
+
+Metrics/LineLength:
+  Max: 99
+
+Metrics/MethodLength:
+  Max: 20
+
+Metrics/BlockLength:
+  ExcludedMethods: ['describe', 'context']
+
+AllCops:
+  Exclude:
+    - 'vendor/**/*'
+    - 'spec/fixtures/**/*'
+    - 'db/**/*'
+    - 'config/**/*'
+    - 'script/**/*'
+    - !ruby/regexp /old_and_unused\.rb$/
+  TargetRubyVersion: 2.4

data/.ruby-version

@@ -1 +1 @@
-ruby-2.3.0@method_decorator
+ruby-2.4.0@method_decorator

data/.travis.yml

@@ -0,0 +1,10 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.4.0
+before_install: gem install bundler -v 1.15.1
+addons:
+  code_climate:
+    repo_token: d4cbcb425982b9f55ea7987bbe97c332550f433610298384819d5dcabed6c334
+after_success:
+  - bundle exec codeclimate-test-reporter

data/Gemfile

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 source 'https://rubygems.org'
 
-gemspec
+gemspec

data/README.rdoc

@@ -1,4 +1,8 @@
 = Method Decorator
+{<img src="https://travis-ci.org/r4z3c/method_decorator.svg?branch=master" alt="Build Status" />}[https://travis-ci.org/r4z3c/method_decorator]
+{<img src="https://codeclimate.com/github/r4z3c/method_decorator/badges/gpa.svg" alt="Code Climate" />}[https://codeclimate.com/github/r4z3c/method_decorator]
+{<img src="https://codeclimate.com/github/r4z3c/method_decorator/badges/coverage.svg" alt="Code Coverage" />}[https://codeclimate.com/github/r4z3c/method_decorator/coverage]
+{<img src="https://codeclimate.com/github/r4z3c/method_decorator/badges/issue_count.svg" alt="Issue Count" />}[https://codeclimate.com/github/r4z3c/method_decorator]
 
 Provides a way to dynamically override methods without losing original behavior.
 

data/Rakefile

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # Rakefile for rake        -*- ruby -*-
 
 # Copyright 2003, 2004, 2005 by Jim Weirich (jim@weirichhouse.org)
@@ -11,7 +13,7 @@ require 'rake/testtask'
 require 'rdoc/task'
 
 Rake::TestTask.new(:test) do |t|
-  t.libs << "test"
+  t.libs << 'test'
   t.verbose = true
   t.test_files = FileList['test/**/test_*.rb']
 end
@@ -27,7 +29,7 @@ end
 require 'rspec/core/rake_task'
 
 RSpec::Core::RakeTask.new(:spec) do |t|
-  t.rspec_opts = %w(--color)
+  t.rspec_opts = %w[--color]
 end
 
-task :default => :spec
+task default: :spec

data/bin/console

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'method_decorator'
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require 'irb'
+IRB.start(__FILE__)

data/lib/method_decorator.rb

@@ -1,84 +1,44 @@
-require 'method_decorator/repository'
-require 'active_support/concern'
-
-module MethodDecorator extend ActiveSupport::Concern
-
-  included do
+# frozen_string_literal: true
 
-    class << self
+require 'active_support/concern'
+require 'method_decorator/services/decorations_service'
 
-      def decorate(target_method_name, &decoration)
-        MethodDecorator.decorate self, target_method_name, &decoration
-      end
+module MethodDecorator
+  extend ActiveSupport::Concern
 
+  class_methods do
+    def decorate(method_name, &decoration)
+      MethodDecorator.decorate self, method_name, &decoration
     end
-
   end
 
   class << self
-
-    def decorate(target_class, target_method_name, &decoration)
-      raise 'target_method_name must be a symbol' unless target_method_name.is_a? Symbol
-      added = add_to_repository(decoration, target_class, target_method_name)
-      override_method(decoration, target_class, target_method_name) if added
-      added
+    def decorate(klass, method_name, &decoration)
+      decorations_service.decorate(klass, method_name, &decoration)
     end
 
-    protected
-
-    def add_to_repository(decoration, target_class, target_method_name)
-      Repository.add(
-        target_class,
-        target_method_name,
-        target_class.instance_method(target_method_name),
-        &decoration
-      )
+    def add_call(klass, method_name, *args, &block)
+      decorations_service.add_call(klass, method_name, *args, &block)
     end
 
-    def override_method(decoration, target_class, target_method_name)
-      is_protected = target_class.protected_instance_methods.include? target_method_name
-      is_private = target_class.private_instance_methods.include? target_method_name
-      define_decorated_method decoration, target_class, target_method_name
-      target_class.instance_eval { protected target_method_name } if is_protected
-      target_class.instance_eval { private target_method_name } if is_private
+    def call_original_method(context, method_name, *args, &block)
+      decorations_service.call_original_method(context, method_name, *args, &block)
     end
 
-    def define_decorated_method(decoration, target_class, target_method_name)
-      target_class.send :define_method, target_method_name do |*args, &block|
-        target_class.send :define_method, :call_args do return *args end
-        target_class.send :define_method, :call_block do return block end
-        target_class.send :define_method, :call_original do
-          MethodDecorator.call_original_method self, target_method_name, *call_args, &call_block
-        end
-        target_class.send :define_method, :call_original_with do |*desired_args, &desired_block|
-          MethodDecorator.call_original_method self, target_method_name, *desired_args, &desired_block
-        end
-        target_class.instance_eval { protected :call_args }
-        target_class.instance_eval { protected :call_block }
-        instance_eval &decoration
-      end
+    def last_call_args(context)
+      decorations_service.last_call_args(context)
     end
 
-    public
-
-    def call_original_method(target_context, target_method_name, *original_args, &original_block)
-      target_class = target_class_from_context(target_context)
-      target_method = Repository.original_target_method_of(target_class, target_method_name)
-      target_method.bind(target_context).call(*original_args, &original_block)
+    def last_call_block(context)
+      decorations_service.last_call_block(context)
     end
 
-    def target_class_from_context(target_context)
-      if target_type_from_context(target_context).eql? :singleton
-        target_context.singleton_class
-      else
-        target_context.class
-      end
+    def last_call_method_name(context)
+      decorations_service.last_call_method_name(context)
     end
 
-    def target_type_from_context(target_context)
-      target_context.class.eql?(Class) ? :singleton : :class
+    def decorations_service
+      MethodDecorator::Services::DecorationsService
     end
-
   end
-
-end
+end

data/lib/method_decorator/errors/already_decorated_error.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module MethodDecorator
+  module Errors
+    class AlreadyDecoratedError < StandardError
+    end
+  end
+end

data/lib/method_decorator/models/call.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'method_decorator/models/model'
+
+module MethodDecorator
+  module Models
+    class Call < Model
+      attr_accessor :klass, :method_name, :args, :block
+
+      def initialize(klass, method_name, *args, &block)
+        self.klass = klass
+        self.method_name = method_name
+        self.args = *args
+        self.block = block
+        validate!
+      end
+
+      protected
+
+      def validate!
+        validate_attr!(:klass, Class)
+        validate_attr!(:method_name, Symbol)
+      end
+    end
+  end
+end

data/lib/method_decorator/models/decoration.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'method_decorator/models/model'
+
+module MethodDecorator
+  module Models
+    class Decoration < Model
+      attr_accessor :klass, :method_name, :method_instance, :decoration
+
+      def initialize(klass, method_name, method_instance)
+        self.klass = klass
+        self.method_name = method_name
+        self.method_instance = method_instance
+        self.decoration = block_given? ? Proc.new : nil
+        validate!
+      end
+
+      protected
+
+      def validate!
+        validate_attr!(:klass, Class)
+        validate_attr!(:method_name, Symbol)
+        validate_attr!(:method_instance, UnboundMethod)
+        validate_attr!(:decoration, Proc)
+      end
+    end
+  end
+end

data/lib/method_decorator/models/model.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module MethodDecorator
+  module Models
+    class Model
+      protected
+
+      def validate!
+        raise(NotImplementedError, "`#{self.class}` must override `validate!`")
+      end
+
+      def validate_attr!(attr, type)
+        value = send(attr)
+        invalid_attr!(attr) unless value
+        invalid_attr!(attr, "must be a `#{type}`") unless value.is_a?(type)
+      end
+
+      def invalid_attr!(attr, error = 'is required')
+        raise(ArgumentError, "`#{attr}` attribute #{error}")
+      end
+    end
+  end
+end

data/lib/method_decorator/repositories/calls_repository.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require 'method_decorator/models/call'
+
+module MethodDecorator
+  module Repositories
+    class CallsRepository
+      attr_writer :calls
+
+      def add(klass, method_name, *args, &block)
+        call = find_call(klass)
+        if call
+          update_existing_call(call, method_name, *args, &block)
+        else
+          push_new_call(klass, method_name, *args, &block)
+        end
+      end
+
+      def find_call(klass)
+        calls.find { |call| call.klass.eql?(klass) }
+      end
+
+      def update_existing_call(call, method_name, *args, &block)
+        call.method_name = method_name
+        call.args = *args
+        call.block = block
+        call
+      end
+
+      def push_new_call(klass, method_name, *args, &block)
+        calls.push(MethodDecorator::Models::Call.new(klass, method_name, *args, &block))
+      end
+
+      def calls
+        @calls ||= []
+      end
+
+      class << self
+        def singleton
+          @singleton ||= new
+        end
+      end
+    end
+  end
+end

data/lib/method_decorator/repositories/decorations_repository.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require 'method_decorator/models/decoration'
+require 'method_decorator/models/call'
+require 'method_decorator/errors/already_decorated_error'
+
+module MethodDecorator
+  module Repositories
+    class DecorationsRepository
+      attr_writer :decorations
+
+      def add!(klass, method_name, method_instance, &decoration)
+        added = add(klass, method_name, method_instance, &decoration)
+        self.class.raise_already_decorated_error(klass, method_name) unless added
+        added
+      end
+
+      def add(klass, method_name, method_instance, &decoration)
+        existing = original_method_instance_of(klass, method_name)
+        unless existing
+          decorations.push(
+            Models::Decoration.new(klass, method_name, method_instance, &decoration)
+          )
+        end
+        !existing
+      end
+
+      def original_method_instance_of(klass, method_name)
+        decoration = find_decoration(klass, method_name)
+        decoration ? decoration.method_instance : nil
+      end
+
+      def find_decoration(klass, method_name)
+        decorations.select do |d|
+          d.klass.eql?(klass) && d.method_name.eql?(method_name)
+        end.first
+      end
+
+      def decorations
+        @decorations ||= []
+      end
+
+      class << self
+        def raise_already_decorated_error(klass, method_name)
+          raise(
+            MethodDecorator::Errors::AlreadyDecoratedError,
+            "`#{klass}` already has a decorated `#{method_name}`"
+          )
+        end
+
+        def singleton
+          @singleton ||= new
+        end
+      end
+    end
+  end
+end

data/lib/method_decorator/services/decorations_service.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+require 'method_decorator/repositories/decorations_repository'
+require 'method_decorator/repositories/calls_repository'
+require 'method_decorator/models/call'
+
+module MethodDecorator
+  module Services
+    class DecorationsService
+      attr_accessor :klass, :method_name, :method_instance, :decoration
+
+      def initialize(klass, method_name, &decoration)
+        self.klass = klass
+        self.method_name = method_name
+        self.method_instance = klass.instance_method(method_name)
+        self.decoration = decoration
+        self
+      end
+
+      def decorate
+        add_decoration_to_repository
+        override_original_klass_method
+        define_helper_methods
+        self
+      end
+
+      protected
+
+      def add_decoration_to_repository
+        self.class.decorations_repository.add!(klass, method_name, method_instance, &decoration)
+      end
+
+      def override_original_klass_method # rubocop:disable Metrics/AbcSize
+        is_protected = klass.protected_instance_methods.include?(method_name)
+        is_private = klass.private_instance_methods.include?(method_name)
+        define_decoration_method
+        method_name_ = method_name
+        klass.instance_eval { protected method_name_ } if is_protected
+        klass.instance_eval { private method_name_ } if is_private
+      end
+
+      def define_decoration_method
+        klass_ = klass
+        method_name_ = method_name
+        decoration_ = decoration
+        klass.send(:define_method, method_name) do |*args, &block|
+          MethodDecorator.add_call(klass_, method_name_, *args, &block)
+          instance_eval(&decoration_)
+        end
+      end
+
+      def define_helper_methods
+        klass.send(:define_method, :call_args) { MethodDecorator.last_call_args(self) }
+        klass.send(:define_method, :call_block) { MethodDecorator.last_call_block(self) }
+        define_original_call_helper_method
+        define_original_call_with_helper_method
+        klass.instance_eval { protected :call_args }
+        klass.instance_eval { protected :call_block }
+      end
+
+      def define_original_call_helper_method
+        klass.send :define_method, :call_original do
+          method_name = MethodDecorator.last_call_method_name(self)
+          MethodDecorator.call_original_method self, method_name, *call_args, &call_block
+        end
+      end
+
+      def define_original_call_with_helper_method
+        klass.send :define_method, :call_original_with do |*desired_args, &desired_block|
+          method_name = MethodDecorator.last_call_method_name(self)
+          MethodDecorator.call_original_method self, method_name, *desired_args, &desired_block
+        end
+      end
+
+      class << self
+        def decorate(klass, method_name, &decoration)
+          new(klass, method_name, &decoration).decorate
+        end
+
+        def add_call(klass, method_name, *args, &block)
+          calls_repository.add(klass, method_name, *args, &block)
+        end
+
+        def call_original_method(context, method_name, *args, &block)
+          klass = get_class_from_context(context)
+          method_instance = decorations_repository.original_method_instance_of(klass, method_name)
+          method_instance.bind(context).call(*args, &block)
+        end
+
+        def last_call_args(context)
+          call = last_call_from_context(context)
+          call && call.args
+        end
+
+        def last_call_block(context)
+          call = last_call_from_context(context)
+          call && call.block
+        end
+
+        def last_call_method_name(context)
+          call = last_call_from_context(context)
+          call && call.method_name
+        end
+
+        def last_call_from_context(context)
+          klass = get_class_from_context(context)
+          calls_repository.find_call(klass)
+        end
+
+        def get_class_from_context(context)
+          if get_type_from_context(context).eql? :singleton
+            context.singleton_class
+          else
+            context.class
+          end
+        end
+
+        def get_type_from_context(context)
+          context.class.eql?(Class) ? :singleton : :class
+        end
+
+        def decorations_repository
+          MethodDecorator::Repositories::DecorationsRepository.singleton
+        end
+
+        def calls_repository
+          MethodDecorator::Repositories::CallsRepository.singleton
+        end
+      end
+    end
+  end
+end

data/lib/method_decorator/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module MethodDecorator
-  VERSION = '3.0.2'
-end
+  VERSION = '4.0.0'
+end

data/method_decorator.gemspec

@@ -1,4 +1,6 @@
-$:.push File.expand_path('../lib', __FILE__)
+# frozen_string_literal: true
+
+$LOAD_PATH.push File.expand_path('../lib', __FILE__)
 
 require 'method_decorator/version'
 
@@ -8,18 +10,22 @@ Gem::Specification.new do |s|
   s.authors     = ['r4z3c']
   s.email       = ['r4z3c.43@gmail.com']
   s.homepage    = 'https://github.com/r4z3c/method_decorator.git'
-  s.summary     = 'Overwrite methods preserving the original behavior'
-  s.description = 'Provides a way to dynamically overwrite methods without losing original behavior'
-  s.licenses    = %w(MIT)
+  s.summary     = 'Override methods preserving the original behavior'
+  s.description = 'Provides a way to dynamically override methods without losing original behavior'
+  s.licenses    = %w[MIT]
 
   s.files = `git ls-files`.split("\n")
   s.test_files = s.files.grep(%r{^(test|spec|features)/})
 
-  s.require_paths = %w(lib)
+  s.require_paths = %w[lib]
 
   s.add_dependency 'bundler', '>= 1'
   s.add_dependency 'activesupport', '>= 4'
 
   s.add_development_dependency 'rspec', '>= 3'
   s.add_development_dependency 'simplecov', '>= 0'
+  s.add_development_dependency 'codeclimate-test-reporter'
+  s.add_development_dependency 'rake'
+  s.add_development_dependency 'rubocop'
+  s.add_development_dependency 'byebug'
 end

data/spec/lib/method_decorator_spec.rb

@@ -1,159 +1,181 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 require 'support/dummy_class'
 
 describe MethodDecorator 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 { expect(target_instance).to receive(:puts).with("a_decorated_public_instance_method_with: #{[dummy_arg]}").ordered }
-        before { expect(target_instance).to receive(:puts).with("a_public_instance_method_arg: #{dummy_arg}").ordered }
+        before do
+          expect(target_instance).to receive(:puts)
+            .with("a_decorated_public_instance_method_with: #{[dummy_arg]}").ordered
+        end
+        before do
+          expect(target_instance).to receive(:puts)
+            .with("a_public_instance_method_arg: #{dummy_arg}").ordered
+        end
 
         it { target_instance.a_public_instance_method dummy_arg }
-
       end
 
       context 'when through module inclusion' do
-
-        before { expect(target_instance).to receive(:puts).with("another_decorated_public_instance_method_with: #{[dummy_arg]}").ordered }
-        before { expect(target_instance).to receive(:puts).with("another_public_instance_method_arg: #{dummy_arg}").ordered }
+        before do
+          expect(target_instance).to receive(:puts)
+            .with("another_decorated_public_instance_method_with: #{[dummy_arg]}").ordered
+        end
+        before do
+          expect(target_instance).to receive(:puts)
+            .with("another_public_instance_method_arg: #{dummy_arg}").ordered
+        end
 
         it { target_instance.another_public_instance_method dummy_arg }
-
       end
-
     end
 
     context 'when protected method' do
-
       context 'when calling original method through `call_original`' do
-
         context 'when calling protected method deliberately' do
-
-          it { expect{target_instance.a_protected_instance_method dummy_arg}.to raise_error NoMethodError }
-
+          it do
+            expect { target_instance.a_protected_instance_method dummy_arg }
+              .to raise_error(NoMethodError)
+          end
         end
 
         context 'when calling protected method through `send`' do
-
-          before { expect(target_instance).to receive(:puts).with("a_decorated_protected_instance_method_with: #{[dummy_arg]}").ordered }
-          before { expect(target_instance).to receive(:puts).with("a_protected_instance_method_arg: #{dummy_arg}").ordered }
+          before do
+            expect(target_instance).to receive(:puts)
+              .with("a_decorated_protected_instance_method_with: #{[dummy_arg]}").ordered
+          end
+          before do
+            expect(target_instance).to receive(:puts)
+              .with("a_protected_instance_method_arg: #{dummy_arg}").ordered
+          end
 
           it { target_instance.send :a_protected_instance_method, dummy_arg }
-
         end
-
       end
 
       context 'when calling original method through `call_original_with`' do
-
         context 'when calling protected method through `send`' do
-
-          before { expect(target_instance).to receive(:puts).with("another_decorated_protected_instance_method_with: #{[dummy_arg]}").ordered }
-          before { expect(target_instance).to receive(:puts).with("another_protected_instance_method_arg: hue").ordered }
+          before do
+            expect(target_instance).to receive(:puts)
+              .with("another_decorated_protected_instance_method_with: #{[dummy_arg]}").ordered
+          end
+          before do
+            expect(target_instance).to receive(:puts)
+              .with('another_protected_instance_method_arg: hue').ordered
+          end
 
           it { target_instance.send :another_protected_instance_method, dummy_arg }
-
         end
-
       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 }
-
+        it do
+          expect { target_instance.a_private_instance_method dummy_arg }
+            .to raise_error(NoMethodError)
+        end
       end
 
       context 'when calling private method through `send`' do
-
-        before { expect(target_instance).to receive(:puts).with("a_decorated_private_instance_method_with: #{[dummy_arg]}").ordered }
-        before { expect(target_instance).to receive(:puts).with("a_private_instance_method_arg: #{dummy_arg}").ordered }
+        before do
+          expect(target_instance).to receive(:puts)
+            .with("a_decorated_private_instance_method_with: #{[dummy_arg]}").ordered
+        end
+        before do
+          expect(target_instance).to receive(:puts)
+            .with("a_private_instance_method_arg: #{dummy_arg}").ordered
+        end
 
         it { target_instance.send :a_private_instance_method, dummy_arg }
-
       end
-
     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 { expect(target_instance).to receive(:puts).with("a_decorated_public_singleton_method_with: #{[dummy_arg]}").ordered }
-        before { expect(target_instance).to receive(:puts).with("a_public_singleton_method_arg: #{dummy_arg}").ordered }
+        before do
+          expect(target_instance).to receive(:puts)
+            .with("a_decorated_public_singleton_method_with: #{[dummy_arg]}").ordered
+        end
+        before do
+          expect(target_instance).to receive(:puts)
+            .with("a_public_singleton_method_arg: #{dummy_arg}").ordered
+        end
 
         it { target_instance.a_public_singleton_method dummy_arg }
-
       end
 
       context 'when through module inclusion' do
-
-        before { expect(target_instance).to receive(:puts).with("another_decorated_public_singleton_method_with: #{[dummy_arg]}").ordered }
-        before { expect(target_instance).to receive(:puts).with("another_public_singleton_method_arg: #{dummy_arg}").ordered }
+        before do
+          expect(target_instance).to receive(:puts)
+            .with("another_decorated_public_singleton_method_with: #{[dummy_arg]}").ordered
+        end
+        before do
+          expect(target_instance).to receive(:puts)
+            .with("another_public_singleton_method_arg: #{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 }
-
+        it do
+          expect do
+            target_instance.a_protected_singleton_method dummy_arg
+          end.to raise_error(NoMethodError)
+        end
       end
 
       context 'when calling protected method through `send`' do
-
-        before { expect(target_instance).to receive(:puts).with("a_decorated_protected_singleton_method_with: #{[dummy_arg]}").ordered }
-        before { expect(target_instance).to receive(:puts).with("a_protected_singleton_method_arg: #{dummy_arg}").ordered }
+        before do
+          expect(target_instance).to receive(:puts)
+            .with("a_decorated_protected_singleton_method_with: #{[dummy_arg]}").ordered
+        end
+        before do
+          expect(target_instance).to receive(:puts)
+            .with("a_protected_singleton_method_arg: #{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 }
-
+        it do
+          expect do
+            target_instance.a_private_singleton_method dummy_arg
+          end.to raise_error NoMethodError
+        end
       end
 
       context 'when calling private method through `send`' do
-
-        before { expect(target_instance).to receive(:puts).with("a_decorated_private_singleton_method_with: #{[dummy_arg]}").ordered }
-        before { expect(target_instance).to receive(:puts).with("a_private_singleton_method_arg: #{dummy_arg}").ordered }
+        before do
+          expect(target_instance).to receive(:puts)
+            .with("a_decorated_private_singleton_method_with: #{[dummy_arg]}").ordered
+        end
+        before do
+          expect(target_instance).to receive(:puts)
+            .with("a_private_singleton_method_arg: #{dummy_arg}").ordered
+        end
 
         it { target_instance.send :a_private_singleton_method, dummy_arg }
-
       end
-
     end
-
   end
-
-end
+end

data/spec/lib/models/call_spec.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'method_decorator/models/call'
+
+describe MethodDecorator::Models::Call do
+  describe '#initialize' do
+    subject { described_class.new(*args, &block) }
+
+    context 'when klass is missing' do
+      let(:args) { [nil, nil] }
+      let(:block) { nil }
+      let(:error) { '`klass` attribute is required' }
+
+      it { expect { subject }.to raise_error(ArgumentError, error) }
+    end
+
+    context 'when klass is not a class' do
+      let(:args) { [:klass, nil] }
+      let(:block) { nil }
+      let(:error) { '`klass` attribute must be a `Class`' }
+
+      it { expect { subject }.to raise_error(ArgumentError, error) }
+    end
+
+    context 'when method name is missing' do
+      let(:args) { [String, nil] }
+      let(:block) { nil }
+      let(:error) { '`method_name` attribute is required' }
+
+      it { expect { subject }.to raise_error(ArgumentError, error) }
+    end
+
+    context 'when method name is not a symbol' do
+      let(:args) { [String, 'method_name'] }
+      let(:block) { nil }
+      let(:error) { '`method_name` attribute must be a `Symbol`' }
+
+      it { expect { subject }.to raise_error(ArgumentError, error) }
+    end
+
+    context 'when everything is ok' do
+      let(:args) { [String, :method_name, :a_first_arg, :a_second_arg] }
+      let(:block) { proc { :a_block } }
+      let(:call) { subject }
+
+      it { expect(call.klass).to eq String }
+      it { expect(call.method_name).to eq :method_name }
+      it { expect(call.args).to eq %i[a_first_arg a_second_arg] }
+      it { expect(call.block).to eq block }
+    end
+  end
+end

data/spec/lib/models/decoration_spec.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'method_decorator/models/decoration'
+require 'method_decorator/models/call'
+
+describe MethodDecorator::Models::Decoration do
+  let(:method_instance) { String.instance_method(:to_s) }
+
+  describe '#initialize' do
+    subject { described_class.new(*args, &block) }
+
+    context 'when `klass` attribute is missing' do
+      let(:args) { [nil, :method_name, method_instance] }
+      let(:block) { proc {} }
+      let(:error) { '`klass` attribute is required' }
+
+      it { expect { subject }.to raise_error(ArgumentError, error) }
+    end
+
+    context 'when `klass` attribute is not a class' do
+      let(:args) { [:klass, :method_name, method_instance] }
+      let(:block) { proc {} }
+      let(:error) { '`klass` attribute must be a `Class`' }
+
+      it { expect { subject }.to raise_error(ArgumentError, error) }
+    end
+
+    context 'when `method_name` attribute is missing' do
+      let(:args) { [String, nil, method_instance] }
+      let(:block) { proc {} }
+      let(:error) { '`method_name` attribute is required' }
+
+      it { expect { subject }.to raise_error(ArgumentError, error) }
+    end
+
+    context 'when `method_name` attribute is not a symbol' do
+      let(:args) { [String, 'method_name', method_instance] }
+      let(:block) { proc {} }
+      let(:error) { '`method_name` attribute must be a `Symbol`' }
+
+      it { expect { subject }.to raise_error(ArgumentError, error) }
+    end
+
+    context 'when `method_instance` attribute is missing' do
+      let(:args) { [String, :method_name, nil] }
+      let(:block) { proc {} }
+      let(:error) { '`method_instance` attribute is required' }
+
+      it { expect { subject }.to raise_error(ArgumentError, error) }
+    end
+
+    context 'when `method_instance` attribute is not a unbound method' do
+      let(:args) { [String, :method_name, :method_instance] }
+      let(:block) { proc {} }
+      let(:error) { '`method_instance` attribute must be a `UnboundMethod`' }
+
+      it { expect { subject }.to raise_error(ArgumentError, error) }
+    end
+
+    context 'when `decoration` attribute is missing' do
+      let(:args) { [String, :method_name, method_instance] }
+      let(:block) { nil }
+      let(:error) { '`decoration` attribute is required' }
+
+      it { expect { subject }.to raise_error(ArgumentError, error) }
+    end
+  end
+end

data/spec/lib/models/model_spec.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'method_decorator/models/model'
+
+describe MethodDecorator::Models::Model do
+  describe '#validate!' do
+    subject { described_class.new.send :validate! }
+    it { expect { subject }.to raise_error(NotImplementedError) }
+  end
+end

data/spec/lib/repositories/calls_repository_spec.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'method_decorator/repositories/calls_repository'
+
+describe MethodDecorator::Repositories::CallsRepository do
+  let(:repo) { described_class.singleton }
+
+  describe '#add' do
+    let(:common_args) { [String, :method_name, :a_first_arg, :a_second_arg] }
+    let(:block) { proc {} }
+
+    before { repo.calls = [] }
+
+    subject { repo.add(*args, &block) }
+
+    context 'when call not exists' do
+      let(:args) { common_args }
+
+      before { subject }
+
+      it { expect(repo.calls.count).to eq 1 }
+      it { expect(subject[0].klass).to eq String }
+      it { expect(subject[0].method_name).to eq :method_name }
+      it { expect(subject[0].args).to eq %i[a_first_arg a_second_arg] }
+      it { expect(subject[0].block).to eq block }
+    end
+
+    context 'when call already exists' do
+      let(:args) { [String, :another_method_name, :another_arg] }
+
+      before { repo.add(*common_args, &block) }
+      before { subject }
+
+      it { expect(repo.calls.count).to eq 1 }
+      it { expect(subject.klass).to eq String }
+      it { expect(subject.method_name).to eq :another_method_name }
+      it { expect(subject.args).to eq %i[another_arg] }
+      it { expect(subject.block).to eq block }
+    end
+  end
+end

data/spec/lib/repositories/decorations_repository_spec.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'method_decorator/repositories/decorations_repository'
+
+describe MethodDecorator::Repositories::DecorationsRepository do
+  let(:repo) { described_class.singleton }
+  let(:method_instance) { String.instance_method(:to_s) }
+
+  before { described_class.singleton.decorations = [] }
+
+  describe '#add!' do
+    let(:args) { [String, :method_name, method_instance] }
+    let(:block) { proc {} }
+
+    subject { repo.add!(*args, &block) }
+
+    context 'when decoration not exists' do
+      it { is_expected.to be_truthy }
+    end
+
+    context 'when decoration already exists' do
+      before { repo.add!(*args, &block) }
+      it { expect { subject }.to raise_error(MethodDecorator::Errors::AlreadyDecoratedError) }
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -1,6 +1,7 @@
-require 'active_support'
+# frozen_string_literal: true
+
 require 'simplecov'
 
 SimpleCov.start
 
-require 'method_decorator'
+require 'method_decorator'

data/spec/support/dummy_class.rb

@@ -1,5 +1,6 @@
-class DummyClass
+# frozen_string_literal: true
 
+class DummyClass
   def a_public_instance_method(arg)
     puts "a_public_instance_method_arg: #{arg}"
   end
@@ -25,7 +26,6 @@ class DummyClass
   end
 
   class << self
-
     def a_public_singleton_method(arg)
       puts "a_public_singleton_method_arg: #{arg}"
     end
@@ -52,7 +52,6 @@ class DummyClass
       puts "another_decorated_public_singleton_method_with: #{call_args}"
       call_original
     end
-
   end
 
   include MethodDecorator
@@ -61,7 +60,6 @@ class DummyClass
     puts "another_decorated_public_instance_method_with: #{call_args}"
     call_original
   end
-
 end
 
 MethodDecorator.decorate DummyClass, :a_public_instance_method do
@@ -97,4 +95,4 @@ end
 MethodDecorator.decorate DummyClass.singleton_class, :a_private_singleton_method do
   puts "a_decorated_private_singleton_method_with: #{call_args}"
   call_original
-end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: method_decorator
 version: !ruby/object:Gem::Version
-  version: 3.0.2
+  version: 4.0.0
 platform: ruby
 authors:
 - r4z3c
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-03-04 00:00:00.000000000 Z
+date: 2017-07-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -66,7 +66,63 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: Provides a way to dynamically overwrite methods without losing original
+- !ruby/object:Gem::Dependency
+  name: codeclimate-test-reporter
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: 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'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: byebug
+  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: Provides a way to dynamically override methods without losing original
   behavior
 email:
 - r4z3c.43@gmail.com
@@ -75,17 +131,30 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
+- ".rubocop.yml"
 - ".ruby-version"
+- ".travis.yml"
 - Gemfile
 - MIT-LICENSE
 - README.rdoc
 - Rakefile
+- bin/console
 - lib/method_decorator.rb
-- lib/method_decorator/decoration.rb
-- lib/method_decorator/repository.rb
+- lib/method_decorator/errors/already_decorated_error.rb
+- lib/method_decorator/models/call.rb
+- lib/method_decorator/models/decoration.rb
+- lib/method_decorator/models/model.rb
+- lib/method_decorator/repositories/calls_repository.rb
+- lib/method_decorator/repositories/decorations_repository.rb
+- lib/method_decorator/services/decorations_service.rb
 - lib/method_decorator/version.rb
 - method_decorator.gemspec
 - spec/lib/method_decorator_spec.rb
+- spec/lib/models/call_spec.rb
+- spec/lib/models/decoration_spec.rb
+- spec/lib/models/model_spec.rb
+- spec/lib/repositories/calls_repository_spec.rb
+- spec/lib/repositories/decorations_repository_spec.rb
 - spec/spec_helper.rb
 - spec/support/dummy_class.rb
 homepage: https://github.com/r4z3c/method_decorator.git
@@ -108,11 +177,16 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 2.6.12
 signing_key: 
 specification_version: 4
-summary: Overwrite methods preserving the original behavior
+summary: Override methods preserving the original behavior
 test_files:
 - spec/lib/method_decorator_spec.rb
+- spec/lib/models/call_spec.rb
+- spec/lib/models/decoration_spec.rb
+- spec/lib/models/model_spec.rb
+- spec/lib/repositories/calls_repository_spec.rb
+- spec/lib/repositories/decorations_repository_spec.rb
 - spec/spec_helper.rb
 - spec/support/dummy_class.rb

data/lib/method_decorator/decoration.rb

@@ -1,14 +0,0 @@
-module MethodDecorator
-  class Decoration
-
-    attr_accessor :target_class, :target_method_name, :target_method, :decoration
-
-    def initialize(target_class, target_method_name, target_method)
-      self.target_class = target_class
-      self.target_method_name = target_method_name
-      self.target_method = target_method
-      self.decoration = block_given? ? Proc.new : nil
-    end
-
-  end
-end

data/lib/method_decorator/repository.rb

@@ -1,30 +0,0 @@
-require 'method_decorator/decoration'
-
-module MethodDecorator
-  class Repository
-    class << self
-
-      attr_writer :decorations
-
-      def add(target_class, target_method_name, target_method, &decoration)
-        exists = original_target_method_of target_class, target_method_name
-
-        self.decorations.push(
-          Decoration.new target_class, target_method_name, target_method, &decoration
-        ) unless exists
-
-        not exists
-      end
-
-      def original_target_method_of(target_class, target_method_name)
-        decoration = self.decorations.select do
-          |d| d.target_class.eql?(target_class) and d.target_method_name.eql?(target_method_name)
-        end.first
-
-        decoration ? decoration.target_method : nil
-      end
-
-      def decorations; @decorations ||= [] end
-    end
-  end
-end