method_decorator 2.0.0 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 607f30fb2f44469cac0ff14b5b6dd1bfa80164ef
-  data.tar.gz: 09ead13f5c6c41d17b7c9cc129d7ee9a1d324ccc
+  metadata.gz: b76ea850afa9489fa5475cb52dce8f6884215b6a
+  data.tar.gz: 9a05e1374523166287151e6790b66e5701ae9c09
 SHA512:
-  metadata.gz: 8a2ce94d7ad57315caaa659efa8c621168943db20b656115469254b10850c4dc73bc038eea00b5394ce499df6d5a95618d757d47e134482a753311e8c53ed120
-  data.tar.gz: 973c2a671be37ebcc7bd3924d3e2d581eeb9cc6740dc84fcdaeff99b800e806691635cc0c45f2c0815668cbd6023bfe71907915e1b001b4bccbc4a609f652d83
+  metadata.gz: 7c088113e4a0803b007944eba4781cd8655f2d907be4a9fcd3493583faa688868b30521706057e2b4b89b39a17e8adfc55d4ece2bac25f85a2bb6c91bb1650cf
+  data.tar.gz: b46674adf3ff149e6fe00ff5bff6df99415ea6a4b7650f96e7d98d090660b52d6dfd04cce6ebb1a772a699ec065c11c8abaf3ea04eaf8574f2d8714fab28d26f

data/README.rdoc

@@ -1,9 +1,11 @@
 = Method Decorator
 
-Provides a way to dynamically overwrite methods without losing original behavior.
+Provides a way to dynamically override methods without losing original behavior.
 
 == Example
 
+For a given class:
+
     class SomeClass
 
         def some_method(some_arg)
@@ -14,7 +16,7 @@ Provides a way to dynamically overwrite methods without losing original behavior
 
     MethodDecorator.decorate SomeClass, :some_method do |*args|
         puts :decorated_some_method
-        MethodDecorator.call_original self, :some_method, *args
+        MethodDecorator.call_original_method self, :some_method, *args
     end
 
 This call:
@@ -44,7 +46,7 @@ It works too:
 
     MethodDecorator.decorate SomeClass.singleton_class, :some_method do |*args|
         puts :decorated_some_method
-        MethodDecorator.call_original self, :some_method, *args
+        MethodDecorator.call_original_method self, :some_method, *args
     end
 
     SomeClass.some_method 'some arg'

data/lib/method_decorator/decoration.rb

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

data/lib/method_decorator/repository.rb

@@ -6,22 +6,25 @@ module MethodDecorator
 
       attr_writer :decorations
 
-      def add_decoration(target_class, target_name, &decoration)
-        exists = original_method target_class, target_name
-        target_method = target_class.instance_method target_name
-        decoration = Decoration.new target_class, target_name, target_method, &decoration
-        self.decorations.push(decoration) unless exists
+      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_method(target_class, target_name)
-        condition = Proc.new { |d| d.target_class.eql?(target_class) and d.target_name.eql?(target_name) }
-        decoration = self.decorations.select(&condition).first
+      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

data/lib/method_decorator/version.rb

@@ -1,3 +1,3 @@
 module MethodDecorator
-  VERSION = '2.0.0'
+  VERSION = '2.1.0'
 end

data/lib/method_decorator.rb

@@ -1,29 +1,55 @@
 require 'method_decorator/repository'
 
 module MethodDecorator
+
   class << self
 
-    def decorate(target_class, target_name, &decoration)
-      added = Repository.add_decoration target_class, target_name, &decoration
-      target_class.send :define_method, target_name, &decoration if added
+    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
     end
 
-    def call_original(target_context, target_name, *original_args, &original_block)
-      target_class = target_class target_context
-      target_method = Repository.original_method target_class, target_name
-      target_method.bind(target_context).call *original_args, &original_block
+    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
+      )
+    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
+      target_class.send :define_method, target_method_name, &decoration
+      target_class.instance_eval { protected target_method_name } if is_protected
+      target_class.instance_eval { private target_method_name } if is_private
     end
 
-    def target_class(target_context)
-      target_type(target_context).eql?(:singleton) ?
-      target_context.singleton_class :
-      target_context.class
+    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)
+    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
     end
 
-    def target_type(target_context)
+    def target_type_from_context(target_context)
       target_context.class.eql?(Class) ? :singleton : :class
     end
 
   end
+
 end

data/spec/lib/method_decorator_spec.rb

@@ -1,26 +1,116 @@
 require 'spec_helper'
-require 'support/some_class'
+require 'support/dummy_class'
 
 describe MethodDecorator do
 
-  let(:some_arg) { :some_arg }
+  let(:dummy_arg) { :dummy_arg }
 
-  subject { target.some_method some_arg }
+  context 'when common class as target' do
 
-  before do
-    expect(target).to receive(:puts).with(:decorated_some_method).ordered
-    expect(target).to receive(:puts).with(some_arg).ordered
-  end
+    let(:target) { DummyClass }
+    let(:target_instance) { target.new }
+
+    context 'when public method' do
+
+      before { expect(target_instance).to receive(:puts).with(:a_decorated_public_instance_method).ordered }
+      before { expect(target_instance).to receive(:puts).with("a_public_instance_method_arg: #{dummy_arg}").ordered }
+
+      it { target_instance.a_public_instance_method dummy_arg }
+
+    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 { expect(target_instance).to receive(:puts).with(:a_decorated_protected_instance_method).ordered }
+        before { expect(target_instance).to receive(:puts).with("a_protected_instance_method_arg: #{dummy_arg}").ordered }
+
+        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 { expect(target_instance).to receive(:puts).with(:a_decorated_private_instance_method).ordered }
+        before { expect(target_instance).to receive(:puts).with("a_private_instance_method_arg: #{dummy_arg}").ordered }
+
+        it { target_instance.send :a_private_instance_method, dummy_arg }
+
+      end
+
+    end
 
-  context 'when singleton method context' do
-    let(:target) { SomeClass }
-    it { subject }
   end
 
-  context 'when instance method context' do
-    let(:target) { SomeClass.new }
-    let(:methods) { target.class.send :generated_methods }
-    it { subject }
+  context 'when singleton class as target' do
+
+    let(:target) { DummyClass.singleton_class }
+    let(:target_instance) { DummyClass }
+
+    context 'when public method' do
+
+      before { expect(target_instance).to receive(:puts).with(:a_decorated_public_singleton_method).ordered }
+      before { expect(target_instance).to receive(:puts).with("a_public_singleton_method_arg: #{dummy_arg}").ordered }
+
+      it { target_instance.a_public_singleton_method dummy_arg }
+
+    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 { expect(target_instance).to receive(:puts).with(:a_decorated_protected_singleton_method).ordered }
+        before { expect(target_instance).to receive(:puts).with("a_protected_singleton_method_arg: #{dummy_arg}").ordered }
+
+        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 { expect(target_instance).to receive(:puts).with(:a_decorated_private_singleton_method).ordered }
+        before { expect(target_instance).to receive(:puts).with("a_private_singleton_method_arg: #{dummy_arg}").ordered }
+
+        it { target_instance.send :a_private_singleton_method, dummy_arg }
+
+      end
+
+    end
+
   end
 
 end

data/spec/support/dummy_class.rb

@@ -0,0 +1,69 @@
+class DummyClass
+
+  def a_public_instance_method(arg)
+    puts "a_public_instance_method_arg: #{arg}"
+  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
+
+    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
+
+  end
+
+end
+
+MethodDecorator.decorate DummyClass, :a_public_instance_method do |*args, &block|
+  puts :a_decorated_public_instance_method
+  MethodDecorator.call_original_method self, :a_public_instance_method, *args, &block
+end
+
+MethodDecorator.decorate DummyClass, :a_protected_instance_method do |*args, &block|
+  puts :a_decorated_protected_instance_method
+  MethodDecorator.call_original_method self, :a_protected_instance_method, *args, &block
+end
+
+MethodDecorator.decorate DummyClass, :a_private_instance_method do |*args, &block|
+  puts :a_decorated_private_instance_method
+  MethodDecorator.call_original_method self, :a_private_instance_method, *args, &block
+end
+
+MethodDecorator.decorate DummyClass.singleton_class, :a_public_singleton_method do |*args, &block|
+  puts :a_decorated_public_singleton_method
+  MethodDecorator.call_original_method self, :a_public_singleton_method, *args, &block
+end
+
+MethodDecorator.decorate DummyClass.singleton_class, :a_protected_singleton_method do |*args, &block|
+  puts :a_decorated_protected_singleton_method
+  MethodDecorator.call_original_method self, :a_protected_singleton_method, *args, &block
+end
+
+MethodDecorator.decorate DummyClass.singleton_class, :a_private_singleton_method do |*args, &block|
+  puts :a_decorated_private_singleton_method
+  MethodDecorator.call_original_method self, :a_private_singleton_method, *args, &block
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: method_decorator
 version: !ruby/object:Gem::Version
-  version: 2.0.0
+  version: 2.1.0
 platform: ruby
 authors:
 - r4z3c
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-11-09 00:00:00.000000000 Z
+date: 2017-02-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -87,7 +87,7 @@ files:
 - method_decorator.gemspec
 - spec/lib/method_decorator_spec.rb
 - spec/spec_helper.rb
-- spec/support/some_class.rb
+- spec/support/dummy_class.rb
 homepage: https://github.com/r4z3c/method_decorator.git
 licenses:
 - MIT
@@ -115,4 +115,4 @@ summary: Overwrite methods preserving the original behavior
 test_files:
 - spec/lib/method_decorator_spec.rb
 - spec/spec_helper.rb
-- spec/support/some_class.rb
+- spec/support/dummy_class.rb

data/spec/support/some_class.rb

@@ -1,22 +0,0 @@
-class SomeClass
-
-  class << self
-
-    def some_method(some_arg)
-      puts some_arg
-    end
-
-  end
-
-  def some_method(some_arg)
-    puts some_arg
-  end
-
-end
-
-[SomeClass, SomeClass.singleton_class].each do |target_class|
-  MethodDecorator.decorate target_class, :some_method do |*args, &block|
-    puts :decorated_some_method
-    MethodDecorator.call_original self, :some_method, *args, &block
-  end
-end