decors 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c33d4924184f251e5ee9c3a372251355e09efe7f
+  data.tar.gz: 9ddc59be81ccc266b78d36b3b9dc656b37c97bc0
+SHA512:
+  metadata.gz: 3b965a9750314f1f8e921510c9e6275eae49ec18c3f8a2285b796700acfb813e9db6aa4f95e9c68d179d1cc2665bf8891c093a9617a94971f44cf4098f1f801e
+  data.tar.gz: 6f6e62a25f06fe9e2d474aa1ec45cc43c85f4e598d070e2b0da5ee9b42d854b8b0a44ab96f5e2d4b4567921dd9ac5a4ee75d8a4b766c46a0820b8b6b008132e4

data/.gitignore

@@ -0,0 +1,4 @@
+.DS_Store
+.rspec
+.rubocop.yml
+*.gem

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+# Decors changelog
+
+## Version 0.1 (Released April 24, 2017)
+
+- First implementation

data/README.md

@@ -0,0 +1,18 @@
+# Decors
+
+#### Yet another implementation of Python Decorators/Java annotation in ruby
+
+Here are other implementations:
+- https://github.com/wycats/ruby_decorators
+- https://github.com/michaelfairley/method_decorators
+- https://github.com/fredwu/ruby_decorators
+- https://gist.github.com/reu/2762650
+
+## Install
+
+Add `gem 'decors'` to your Gemfile and then `bundle`
+
+## Usage
+
+## License
+

data/decors.gemspec

@@ -0,0 +1,22 @@
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+require 'decors'
+
+Gem::Specification.new do |gem|
+    gem.name          = "decors"
+    gem.version       = ::Decors::VERSION
+    gem.authors       = ['Vivien Meyet']
+    gem.email         = ['vivien@getbannerman.com']
+    gem.description   = "Ruby implementation of Python method decorators / Java annotations"
+    gem.summary       = gem.description
+    gem.homepage      = 'https://github.com/getbannerman/decors'
+
+    gem.files         = `git ls-files`.split($INPUT_RECORD_SEPARATOR)
+    gem.executables   = gem.files.grep(%r{^bin/}).map { |f| File.basename(f) }
+    gem.test_files    = gem.files.grep(%r{^spec/})
+    gem.require_paths = ['lib']
+
+    gem.add_development_dependency 'pry-byebug', '~> 0'
+    gem.add_development_dependency 'rspec', '~> 0'
+end

data/lib/decors/decorator_base.rb

@@ -0,0 +1,25 @@
+module Decors
+    class DecoratorBase
+        attr_reader :decorated_class, :decorated_method, :decorator_args, :decorator_kwargs, :decorator_block
+
+        def initialize(decorated_class, decorated_method, *args, **kwargs, &block)
+            @decorated_class = decorated_class
+            @decorated_method = decorated_method
+            @decorator_args = args
+            @decorator_kwargs = kwargs
+            @decorator_block = block
+        end
+
+        def call(instance, *args, &block)
+            undecorated_call(instance, *args, &block)
+        end
+
+        def undecorated_call(instance, *args, &block)
+            decorated_method.bind(instance).call(*args, &block)
+        end
+
+        def decorated_method_name
+            decorated_method.name
+        end
+    end
+end

data/lib/decors/decorator_definition.rb

@@ -0,0 +1,17 @@
+module Decors
+    module DecoratorDefinition
+        def define_mixin_decorator(decorator_name, decorator_class)
+            define_decorator(decorator_name, decorator_class, mixin: true)
+        end
+
+        def define_decorator(decorator_name, decorator_class, mixin: false)
+            method_definer = mixin ? :define_method : :define_singleton_method
+
+            send(method_definer, decorator_name) do |*params, &blk|
+                ctx = self.singleton_class? ? ObjectSpace.each_object(self).first : self
+                ctx.send(:extend, MethodAddedListener)
+                ctx.declared_decorators << [decorator_class, params, blk]
+            end
+        end
+    end
+end

data/lib/decors/method_added_listener.rb

@@ -0,0 +1,35 @@
+module Decors
+    # Mixin that add method_added hooks
+    module MethodAddedListener
+        def method_added(meth)
+            super
+            handle_method_addition(self, meth)
+        end
+
+        def singleton_method_added(meth)
+            super
+            handle_method_addition(singleton_class, meth)
+        end
+
+        def declared_decorators
+            @declared_decorators ||= []
+        end
+
+        private
+
+        # method addition handling is the same for singleton and instance method
+        def handle_method_addition(clazz, method_name)
+            # @_ignore_additions allows to temporarily disable the hook
+            return if @_ignore_additions || declared_decorators.empty?
+            decorator_class, params, blk = declared_decorators.pop
+
+            decorated_method = clazz.instance_method(method_name)
+
+            @_ignore_additions = true
+            decorator = decorator_class.new(clazz, decorated_method, *params, &blk)
+            @_ignore_additions = false
+
+            clazz.send(:define_method, method_name) { |*args, &block| decorator.call(self, *args, &block) }
+        end
+    end
+end

data/lib/decors.rb

@@ -0,0 +1,7 @@
+require 'decors/decorator_base'
+require 'decors/decorator_definition'
+require 'decors/method_added_listener'
+
+module Decors
+    VERSION = '0.1.0'
+end

data/spec/decors_spec.rb

@@ -0,0 +1,369 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe Decors do
+    before { stub_class(:TestClass) { extend Decors::DecoratorDefinition } }
+    before {
+        stub_class(:Spy) {
+            def self.passed_args(*args, **kwargs, &block)
+                arguments(args: args, kwargs: kwargs, evald_block: block&.call)
+            end
+
+            def self.arguments(*); end
+        }
+    }
+
+    context 'when simple case decorator' do
+        before {
+            stub_class(:SimpleDecorator, inherits: [::Decors::DecoratorBase]) {
+                def initialize(decorated_class, decorated_method, *deco_args, **deco_kwargs, &deco_block)
+                    super
+                    Spy.passed_args(*deco_args, **deco_kwargs, &deco_block)
+                end
+
+                def call(instance, *args, &block)
+                    super
+                    Spy.passed_args(*args, &block)
+                end
+            }
+
+            TestClass.class_eval { define_decorator :SimpleDecorator, SimpleDecorator }
+        }
+
+        context 'It receive all the parameters at initialization' do
+            it { expect(SimpleDecorator).to receive(:new).with(TestClass, anything, 1, 2, a: 3).and_call_original }
+            it { expect(Spy).to receive(:arguments).with(args: [1, 2], kwargs: { a: 3 }, evald_block: 'ok') }
+
+            after {
+                TestClass.class_eval {
+                    SimpleDecorator(1, 2, a: 3) { 'ok' }
+                    def test_method(*); end
+
+                    def test_method_not_decorated(*); end
+                }
+            }
+        end
+
+        context 'It receive the instance and the arguments passed to the method when called' do
+            let(:instance) { TestClass.new }
+            before {
+                TestClass.class_eval {
+                    SimpleDecorator()
+                    def test_method(*args, &block)
+                        Spy.passed_args(*args, &block)
+                    end
+
+                    def test_method_not_decorated; end
+                }
+            }
+
+            it { expect_any_instance_of(SimpleDecorator).to receive(:call).with(instance, 1, a: 2, b: 3, &proc { 'yes' }) }
+            it { expect(Spy).to receive(:arguments).with(args: [1], kwargs: { a: 2, b: 3 }, evald_block: 'yes').twice }
+
+            after {
+                instance.test_method(1, a: 2, b: 3) { 'yes' }
+                instance.test_method_not_decorated
+            }
+        end
+    end
+
+    context 'when decorator is defining a method during initialization' do
+        before {
+            stub_class(:StrangeDecorator, inherits: [::Decors::DecoratorBase]) {
+                def initialize(decorated_class, decorated_method, *deco_args, **deco_kwargs, &deco_block)
+                    super
+                    decorated_class.send(:define_method, :foo) { 42 }
+                end
+
+                def call(*)
+                    super * 2
+                end
+            }
+
+            TestClass.class_eval { define_decorator :StrangeDecorator, StrangeDecorator }
+        }
+
+        before {
+            TestClass.class_eval {
+                StrangeDecorator()
+                StrangeDecorator()
+                def test_method
+                    5
+                end
+            }
+        }
+
+        it { expect(TestClass.new.test_method).to eq 5 * 2 * 2 }
+        it { expect(TestClass.new.foo).to eq 42 }
+    end
+
+    context 'when mutiple decorators' do
+        before {
+            Spy.class_eval {
+                @ordered_calls = []
+
+                class << self
+                    attr_reader :ordered_calls
+
+                    def calling(name)
+                        self.ordered_calls << name
+                    end
+                end
+            }
+
+            stub_class(:Deco1, inherits: [::Decors::DecoratorBase]) {
+                def call(*)
+                    Spy.calling(:deco1_before)
+                    super
+                    Spy.calling(:deco1_after)
+                end
+            }
+
+            stub_class(:Deco2, inherits: [::Decors::DecoratorBase]) {
+                def call(*)
+                    Spy.calling(:deco2_before)
+                    super
+                    Spy.calling(:deco2_after)
+                end
+            }
+
+            TestClass.class_eval {
+                define_decorator :Deco1, Deco1
+                define_decorator :Deco2, Deco2
+
+                Deco2()
+                Deco1()
+                def test_method(*)
+                    Spy.calling(:inside)
+                end
+            }
+        }
+
+        before { TestClass.new.test_method }
+        it { expect(Spy.ordered_calls).to eq [:deco2_before, :deco1_before, :inside, :deco1_after, :deco2_after] }
+    end
+
+    context 'when method has return value' do
+        before {
+            stub_class(:ModifierDeco, inherits: [::Decors::DecoratorBase])
+
+            TestClass.class_eval {
+                define_decorator :ModifierDeco, ModifierDeco
+
+                ModifierDeco()
+                def test_method
+                    :ok
+                end
+            }
+        }
+
+        it { expect(TestClass.new.test_method).to eq :ok }
+    end
+
+    context 'when method has arguments' do
+        before {
+            stub_class(:ModifierDeco, inherits: [::Decors::DecoratorBase])
+
+            TestClass.class_eval {
+                define_decorator :ModifierDeco, ModifierDeco
+
+                ModifierDeco()
+                def test_method(*args, &block)
+                    Spy.passed_args(*args, &block)
+                end
+            }
+        }
+
+        it { expect(Spy).to receive(:arguments).with(args: [1, 2, 3], kwargs: { a: :a }, evald_block: 'yay') }
+        after { TestClass.new.test_method(1, 2, 3, a: :a) { 'yay' } }
+    end
+
+    context 'when changing arguments given to the method' do
+        before {
+            stub_class(:ModifierDeco, inherits: [::Decors::DecoratorBase]) {
+                def call(instance, *)
+                    undecorated_call(instance, 1, 2, 3, a: :a, &proc { 'yay' })
+                end
+            }
+
+            TestClass.class_eval {
+                define_decorator :ModifierDeco, ModifierDeco
+
+                ModifierDeco()
+                def test_method(*args, &block)
+                    Spy.passed_args(*args, &block)
+                end
+            }
+        }
+
+        it { expect(Spy).to receive(:arguments).with(args: [1, 2, 3], kwargs: { a: :a }, evald_block: 'yay') }
+        after { TestClass.new.test_method }
+    end
+
+    context 'when method is recursive' do
+        before {
+            stub_class(:AddOneToArg, inherits: [::Decors::DecoratorBase]) {
+                def call(instance, *args)
+                    undecorated_call(instance, args.first + 1)
+                end
+            }
+
+            TestClass.class_eval {
+                define_decorator :AddOneToArg, AddOneToArg
+
+                AddOneToArg()
+                def test_method(n)
+                    return 0 if n.zero?
+                    n + test_method(n - 2)
+                end
+            }
+        }
+
+        it { expect(TestClass.new.test_method(4)).to eq 5 + 4 + 3 + 2 + 1 }
+    end
+
+    context 'when already has a method_added' do
+        before {
+            stub_module(:TestMixin) {
+                def method_added(*)
+                    Spy.called
+                end
+            }
+            stub_class(:Deco, inherits: [::Decors::DecoratorBase])
+        }
+        it { expect(Spy).to receive(:called) }
+
+        after {
+            TestClass.class_eval {
+                extend TestMixin
+
+                define_decorator :Deco, Deco
+
+                def test_method; end
+            }
+        }
+    end
+
+    context 'when inherited' do
+        before {
+            stub_class(:Deco, inherits: [::Decors::DecoratorBase])
+
+            TestClass.class_eval {
+                define_decorator :Deco, Deco
+
+                Deco()
+                def test_method
+                    :ok
+                end
+            }
+        }
+
+        it {
+            stub_class(:TestClass2, inherits: [TestClass])
+            TestClass2.class_eval {
+                Deco()
+                def test_method
+                    :ko
+                end
+            }
+
+            expect(TestClass.new.test_method).to eq :ok
+            expect(TestClass2.new.test_method).to eq :ko
+        }
+
+        it {
+            stub_class(:TestClass3, inherits: [TestClass])
+
+            TestClass3.class_eval {
+                Deco()
+                def test_method
+                    "this is #{super}"
+                end
+            }
+
+            expect(TestClass3.new.test_method).to eq 'this is ok'
+        }
+    end
+
+    context 'when decorating a class method' do
+        before {
+            stub_class(:Deco, inherits: [::Decors::DecoratorBase]) {
+                def call(*)
+                    super
+                    Spy.called
+                end
+            }
+        }
+
+        context 'when mixin extended on the class (singleton method in class)' do
+            before {
+                TestClass.class_eval {
+                    define_decorator :Deco, Deco
+
+                    Deco()
+                    def self.test_method
+                        :ok
+                    end
+                }
+            }
+
+            it { expect(Spy).to receive(:called) }
+            after { TestClass.test_method }
+        end
+
+        context 'when mixin extended on the class (method in singleton class)' do
+            before {
+                TestClass.class_eval {
+                    class << self
+                        extend Decors::DecoratorDefinition
+
+                        define_decorator :Deco, Deco
+
+                        Deco()
+                        def test_method
+                            :ok
+                        end
+                    end
+                }
+            }
+
+            it { expect(Spy).to receive(:called) }
+            after { TestClass.test_method }
+        end
+
+        context 'when mixin extended on the class (both method in singleton class and singleton method in class)' do
+            before {
+                TestClass.class_eval {
+                    define_decorator :Deco, Deco
+
+                    Deco()
+                    def self.test_method__in_class
+                        :ok
+                    end
+
+                    def self.untest_method__in_class
+                    end
+
+                    class << self
+                        extend Decors::DecoratorDefinition
+
+                        define_decorator :Deco, Deco
+
+                        Deco()
+                        def test_method__in_singleton
+                            :ok
+                        end
+
+                        def untest_method__in_singleton
+                        end
+                    end
+                }
+            }
+
+            it { expect(Spy).to receive(:called) and TestClass.test_method__in_class }
+            it { expect(Spy).to receive(:called) and TestClass.test_method__in_singleton }
+            it { expect(Spy).to_not receive(:called) and TestClass.untest_method__in_class }
+            it { expect(Spy).to_not receive(:called) and TestClass.untest_method__in_singleton }
+        end
+    end
+end
+

data/spec/spec_helper.rb

@@ -0,0 +1,19 @@
+require File.expand_path('../../lib/decors', __FILE__)
+
+module SpecHelpers
+    def stub_class(class_name, inherits: [], &class_eval)
+        klass = stub_const(class_name.to_s, Class.new(*inherits))
+        klass.class_eval(&class_eval) if class_eval
+        klass
+    end
+
+    def stub_module(module_name, &module_eval)
+        mod = stub_const(module_name.to_s, Module.new)
+        mod.module_eval(&module_eval) if module_eval
+        mod
+    end
+end
+
+RSpec.configure do |config|
+    config.include SpecHelpers
+end

metadata

@@ -0,0 +1,83 @@
+--- !ruby/object:Gem::Specification
+name: decors
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Vivien Meyet
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-04-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: pry-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'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  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: Ruby implementation of Python method decorators / Java annotations
+email:
+- vivien@getbannerman.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- CHANGELOG.md
+- README.md
+- decors.gemspec
+- lib/decors.rb
+- lib/decors/decorator_base.rb
+- lib/decors/decorator_definition.rb
+- lib/decors/method_added_listener.rb
+- spec/decors_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/getbannerman/decors
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.8
+signing_key: 
+specification_version: 4
+summary: Ruby implementation of Python method decorators / Java annotations
+test_files:
+- spec/decors_spec.rb
+- spec/spec_helper.rb