decors 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 2bb31ed84c4aa6d83763802dd3ffed2c76b3fdd8
-  data.tar.gz: 60f07758499467ca63547d13bcff6354a845d3a9
+SHA256:
+  metadata.gz: d902a52f74b8a1de84fe0a26df7130072acfb771ee854a5d6382ce4920979a43
+  data.tar.gz: eca2c708367d25e3172ca5fa8e948c97e8b18119e29740c1272a102c267ea6e7
 SHA512:
-  metadata.gz: 8a2651655043a8bc0742fe60db5385989d7e415ae7a2728a3247b61934d7069af5a8b4b02cebde2523228433b0f278aa5805ab273886b7636dae829f725deb06
-  data.tar.gz: ac7ee42f12a9945822fd48017e33977d7b1a364a2ab20b157d6293cbc0847f73254e4a54d0d2dee8f754c45b6e7147c03530dad9033c10ecd55fce356f6e8502
+  metadata.gz: 01c57e83cd0f5b2c3d543de6c06f97bcfd247c2478474d655a2ed0e9b05571ed85fce56e5590cd8a05b92bc16c25542fd21ffeb208fa0e3ff7f4577603d206f8
+  data.tar.gz: 182efe4fb2899bb5e58019249e4105966ce2b7dbdcff729dfb14e82e78e5561d6c0b0fa424900537d6b7ac522a1837f4fc5d7eb415598ec932469fa1e1248f70

data/.ruby-version

@@ -1 +1 @@
-2.3.1
+2.7.1

data/CHANGELOG.md

@@ -1,5 +1,8 @@
 # Decors changelog
 
+## Version 0.4 (Released June 16, 2019)
+- (compatibility) remove warning for ruby 2.7
+
 ## Version 0.3 (Released August 24, 2017)
 
 - (feature) expose decorated method before and after decoration (https://github.com/getbannerman/decors/issues/10)

data/Gemfile

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 ruby File.open('./.ruby-version').readline.split("\n").first
 
 source 'https://rubygems.org' do

data/Gemfile.lock

@@ -1,43 +1,41 @@
 PATH
   remote: .
   specs:
-    decors (0.1.0)
+    decors (0.4.0)
 
 GEM
   remote: https://rubygems.org/
   specs:
-    coderay (1.1.1)
+    coderay (1.1.3)
     diff-lcs (1.3)
-    method_source (0.8.2)
-    pry (0.10.4)
-      coderay (~> 1.1.0)
-      method_source (~> 0.8.1)
-      slop (~> 3.4)
-    rspec (3.5.0)
-      rspec-core (~> 3.5.0)
-      rspec-expectations (~> 3.5.0)
-      rspec-mocks (~> 3.5.0)
-    rspec-core (3.5.4)
-      rspec-support (~> 3.5.0)
-    rspec-expectations (3.5.0)
+    method_source (1.0.0)
+    pry (0.13.1)
+      coderay (~> 1.1)
+      method_source (~> 1.0)
+    rspec (3.9.0)
+      rspec-core (~> 3.9.0)
+      rspec-expectations (~> 3.9.0)
+      rspec-mocks (~> 3.9.0)
+    rspec-core (3.9.2)
+      rspec-support (~> 3.9.3)
+    rspec-expectations (3.9.2)
       diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.5.0)
-    rspec-mocks (3.5.0)
+      rspec-support (~> 3.9.0)
+    rspec-mocks (3.9.1)
       diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.5.0)
-    rspec-support (3.5.0)
-    slop (3.6.0)
+      rspec-support (~> 3.9.0)
+    rspec-support (3.9.3)
 
 PLATFORMS
   ruby
 
 DEPENDENCIES
   decors!
-  pry!
+  pry (~> 0)!
   rspec (~> 3)!
 
 RUBY VERSION
-   ruby 2.3.1p112
+   ruby 2.7.1p83
 
 BUNDLED WITH
-   1.14.6
+   2.1.4

data/decors.gemspec

@@ -1,23 +1,25 @@
-lib = File.expand_path('../lib', __FILE__)
+# frozen_string_literal: true
+
+lib = File.expand_path('lib', __dir__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 
 require 'decors'
 
 Gem::Specification.new do |gem|
-    gem.name          = "decors"
-    gem.version       = ::Decors::VERSION
-    gem.licenses      = ['MIT']
-    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.name = 'decors'
+  gem.version       = ::Decors::VERSION
+  gem.licenses      = ['MIT']
+  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.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', '~> 0'
-    gem.add_development_dependency 'rspec', '~> 3'
+  gem.add_development_dependency 'pry', '~> 0'
+  gem.add_development_dependency 'rspec', '~> 3'
 end

data/lib/decors.rb

@@ -1,7 +1,9 @@
+# frozen_string_literal: true
+
 require 'decors/decorator_base'
 require 'decors/decorator_definition'
 require 'decors/method_added'
 
 module Decors
-    VERSION = '0.3.0'
+  VERSION = '0.4.0'
 end

data/lib/decors/decorator_base.rb

@@ -1,27 +1,29 @@
+# frozen_string_literal: true
+
 module Decors
-    class DecoratorBase
-        attr_reader :decorated_class, :undecorated_method, :decorated_method, :decorator_args,
-            :decorator_kwargs, :decorator_block
+  class DecoratorBase
+    attr_reader :decorated_class, :undecorated_method, :decorated_method, :decorator_args,
+                :decorator_kwargs, :decorator_block
 
-        def initialize(decorated_class, undecorated_method, decorated_method, *args, **kwargs, &block)
-            @decorated_class = decorated_class
-            @undecorated_method = undecorated_method
-            @decorated_method = decorated_method
-            @decorator_args = args
-            @decorator_kwargs = kwargs
-            @decorator_block = block
-        end
+    def initialize(decorated_class, undecorated_method, decorated_method, *args, **kwargs, &block)
+      @decorated_class = decorated_class
+      @undecorated_method = undecorated_method
+      @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 call(instance, *args, **kwargs, &block)
+      undecorated_call(instance, *args, **kwargs, &block)
+    end
 
-        def undecorated_call(instance, *args, &block)
-            undecorated_method.bind(instance).call(*args, &block)
-        end
+    def undecorated_call(instance, *args, **kwargs, &block)
+      undecorated_method.bind(instance).call(*args, **kwargs, &block)
+    end
 
-        def decorated_method_name
-            decorated_method.name
-        end
+    def decorated_method_name
+      decorated_method.name
     end
+  end
 end

data/lib/decors/decorator_definition.rb

@@ -1,17 +1,19 @@
+# frozen_string_literal: true
+
 module Decors
-    module DecoratorDefinition
-        def define_mixin_decorator(decorator_name, decorator_class)
-            define_decorator(decorator_name, decorator_class, mixin: true)
-        end
+  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
+    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|
-                extend(singleton_class? ? Decors::MethodAdded::SingletonListener : Decors::MethodAdded::StandardListener)
+      send(method_definer, decorator_name) do |*args, **kwargs, &blk|
+        extend(singleton_class? ? Decors::MethodAdded::SingletonListener : Decors::MethodAdded::StandardListener)
 
-                declared_decorators << [decorator_class, params, blk]
-            end
-        end
+        declared_decorators << [decorator_class, args, kwargs, blk]
+      end
     end
+  end
 end

data/lib/decors/method_added.rb

@@ -1,67 +1,75 @@
+# frozen_string_literal: true
+
 require 'decors/utils'
 
 module Decors
-    module MethodAdded
-        module Handler
-            private
-
-            METHOD_CALLED_TOO_EARLY_HANDLER = ->(*) {
-                raise 'You cannot call a decorated method before its decorator is initialized'
-            }
-
-            def declared_decorators
-                @declared_decorators ||= []
-            end
-
-            # 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
-
-                undecorated_method = clazz.instance_method(method_name)
-                decorator = METHOD_CALLED_TOO_EARLY_HANDLER
-                clazz.send(:define_method, method_name) { |*args, &block| decorator.call(self, *args, &block) }
-                decorated_method = clazz.instance_method(method_name)
-                @_ignore_additions = true
-                decorator = decorator_class.new(clazz, undecorated_method, decorated_method, *params, &blk)
-                @_ignore_additions = false
-                clazz.send(Decors::Utils.method_visibility(undecorated_method), method_name)
-            end
-        end
+  module MethodAdded
+    module Handler
+      private
+
+      METHOD_CALLED_TOO_EARLY_HANDLER = lambda { |*|
+        raise 'You cannot call a decorated method before its decorator is initialized'
+      }
 
-        module StandardListener
-            include ::Decors::MethodAdded::Handler
+      def declared_decorators
+        @declared_decorators ||= []
+      end
 
-            def method_added(meth)
-                super
-                handle_method_addition(self, meth)
-            end
+      # 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?
 
-            def singleton_method_added(meth)
-                super
-                handle_method_addition(singleton_class, meth)
-            end
+        decorator_class, params, kparams, blk = declared_decorators.pop
+
+        undecorated_method = clazz.instance_method(method_name)
+        decorator = METHOD_CALLED_TOO_EARLY_HANDLER
+
+        clazz.send(:define_method, method_name) do |*args, **kwargs, &block|
+          decorator.call(self, *args, **kwargs, &block)
         end
 
-        module SingletonListener
-            include ::Decors::MethodAdded::Handler
+        decorated_method = clazz.instance_method(method_name)
+        @_ignore_additions = true
+        decorator = decorator_class.new(clazz, undecorated_method, decorated_method, *params, **kparams, &blk)
+        @_ignore_additions = false
+
+        clazz.send(Decors::Utils.method_visibility(undecorated_method), method_name)
+      end
+    end
+
+    module StandardListener
+      include ::Decors::MethodAdded::Handler
+
+      def method_added(meth)
+        super
+        handle_method_addition(self, meth)
+      end
+
+      def singleton_method_added(meth)
+        super
+        handle_method_addition(singleton_class, meth)
+      end
+    end
+
+    module SingletonListener
+      include ::Decors::MethodAdded::Handler
 
-            def singleton_method_added(meth)
-                super
-                handle_method_addition(singleton_class, meth)
-            end
+      def singleton_method_added(meth)
+        super
+        handle_method_addition(singleton_class, meth)
+      end
 
-            def self.extended(base)
-                ObjectSpace.each_object(base).first.send(:extend, ForwardToSingletonListener)
-            end
+      def self.extended(base)
+        ObjectSpace.each_object(base).first.send(:extend, ForwardToSingletonListener)
+      end
 
-            module ForwardToSingletonListener
-                def singleton_method_added(meth)
-                    super
-                    singleton_class.send(:handle_method_addition, singleton_class, meth)
-                end
-            end
+      module ForwardToSingletonListener
+        def singleton_method_added(meth)
+          super
+          singleton_class.send(:handle_method_addition, singleton_class, meth)
         end
+      end
     end
+  end
 end

data/lib/decors/utils.rb

@@ -1,17 +1,19 @@
+# frozen_string_literal: true
+
 module Decors
-    module Utils
-        class << self
-            def method_visibility(method)
-                if method.owner.private_method_defined?(method.name)
-                    :private
-                elsif method.owner.protected_method_defined?(method.name)
-                    :protected
-                elsif method.owner.public_method_defined?(method.name)
-                    :public
-                else
-                    fail ArgumentError, 'Unkwnown method'
-                end
-            end
+  module Utils
+    class << self
+      def method_visibility(method)
+        if method.owner.private_method_defined?(method.name)
+          :private
+        elsif method.owner.protected_method_defined?(method.name)
+          :protected
+        elsif method.owner.public_method_defined?(method.name)
+          :public
+        else
+          raise ArgumentError, 'Unkwnown method'
         end
+      end
     end
+  end
 end

data/spec/decors_spec.rb

@@ -1,456 +1,458 @@
+# frozen_string_literal: true
+
 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
+  before { stub_class(:TestClass) { extend Decors::DecoratorDefinition } }
+  before do
+    stub_class(:Spy) do
+      def self.passed_args(*args, **kwargs, &block)
+        arguments(args: args, kwargs: kwargs, evald_block: block&.call)
+      end
+
+      def self.arguments(**); end
+    end
+  end
+
+  context 'Check decorated_method & undecorated_method' do
+    let(:instance) { TestClass.new }
+
+    before do
+      stub_class(:SimpleDecorator, inherits: [::Decors::DecoratorBase])
+      call_method = call_proc
+      SimpleDecorator.send(:define_method, :call) { |*| instance_eval(&call_method) }
+      TestClass.class_eval do
+        define_decorator :SimpleDecorator, SimpleDecorator
+        SimpleDecorator()
+        def test
+          42
+        end
+      end
+    end
 
-            def self.arguments(*); end
-        }
-    }
+    context 'Check decorated_method value' do
+      let(:call_proc) { proc { decorated_method } }
+      it { expect(instance.test).to eq TestClass.instance_method(:test) }
+    end
 
-    context 'Check decorated_method & undecorated_method' do
-        let(:instance) { TestClass.new }
-
-        before {
-            stub_class(:SimpleDecorator, inherits: [::Decors::DecoratorBase])
-            call_method = call_proc
-            SimpleDecorator.send(:define_method, :call){ |*| instance_eval(&call_method) }
-            TestClass.class_eval {
-                define_decorator :SimpleDecorator, SimpleDecorator
-                SimpleDecorator()
-                def test; 42 end
-            }
-        }
-
-        context 'Check decorated_method value' do
-            let(:call_proc) { proc { decorated_method } }
-            it { expect(instance.test).to eq TestClass.instance_method(:test) }
+    context 'Check undecorated_method value' do
+      let(:call_proc) { proc { undecorated_method } }
+      it { expect(instance.test.bind(instance).call).to eq 42 }
+      it { expect(instance.test.bind(instance).call).not_to eq TestClass.instance_method(:test) }
+    end
+  end
+
+  context 'when simple case decorator' do
+    before do
+      stub_class(:SimpleDecorator, inherits: [::Decors::DecoratorBase]) do
+        def initialize(deco_class, undeco_method, deco_method, *deco_args, **deco_kwargs, &deco_block)
+          super
+          Spy.passed_args(*deco_args, **deco_kwargs, &deco_block)
         end
 
-        context 'Check undecorated_method value' do
-            let(:call_proc) { proc { undecorated_method } }
-            it { expect(instance.test.bind(instance).call).to eq 42 }
-            it { expect(instance.test.bind(instance).call).not_to eq TestClass.instance_method(:test) }
+        def call(instance, *args, **kwargs, &block)
+          super
+          Spy.passed_args(*args, **kwargs, &block)
+        end
+      end
+
+      TestClass.class_eval { define_decorator :SimpleDecorator, SimpleDecorator }
+    end
 
+    context 'It receive all the parameters at initialization' do
+      it { expect(SimpleDecorator).to receive(:new).with(TestClass, anything, 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 do
+        TestClass.class_eval do
+          SimpleDecorator(1, 2, a: 3) { 'ok' }
+          def test_method(*); end
+
+          def test_method_not_decorated(*); end
         end
+      end
     end
 
-    context 'when simple case decorator' do
-        before {
-            stub_class(:SimpleDecorator, inherits: [::Decors::DecoratorBase]) {
-                def initialize(decorated_class, undecorated_method, 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, 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
-                }
-            }
+    context 'It receive the instance and the arguments passed to the method when called' do
+      let(:instance) { TestClass.new }
+      before do
+        TestClass.class_eval do
+          SimpleDecorator()
+          def test_method(*args, **kwargs, &block)
+            Spy.passed_args(*args, **kwargs, &block)
+          end
+
+          def test_method_not_decorated; end
         end
+      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 do
+        instance.test_method(1, a: 2, b: 3) { 'yes' }
+        instance.test_method_not_decorated
+      end
+    end
+
+    context 'It keep the method visibility' do
+      before do
+        TestClass.class_eval do
+          SimpleDecorator()
+          public def public_test_method(*); end
+
+          SimpleDecorator()
+          private def private_test_method(*); 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
-            }
+          SimpleDecorator()
+          protected def protected_test_method(*); end
         end
+      end
 
-        context 'It keep the method visibility' do
-            before {
-                TestClass.class_eval {
-                    SimpleDecorator()
-                    public def public_test_method(*); end
+      it { expect(TestClass).to be_public_method_defined(:public_test_method) }
+      it { expect(TestClass).to be_protected_method_defined(:protected_test_method) }
+      it { expect(TestClass).to be_private_method_defined(:private_test_method) }
+    end
+  end
+
+  context 'when decorator is defining a method during initialization' do
+    before do
+      stub_class(:StrangeDecorator, inherits: [::Decors::DecoratorBase]) do
+        def initialize(decorated_class, undecorated_method, decorated_method, *deco_args, **deco_kwargs, &deco_block)
+          super
+          decorated_class.send(:define_method, :foo) { 42 }
+        end
 
-                    SimpleDecorator()
-                    private def private_test_method(*); end
+        def call(*)
+          super * 2
+        end
+      end
 
-                    SimpleDecorator()
-                    protected def protected_test_method(*); end
-                }
-            }
+      TestClass.class_eval { define_decorator :StrangeDecorator, StrangeDecorator }
+    end
 
-            it { expect(TestClass).to be_public_method_defined(:public_test_method) }
-            it { expect(TestClass).to be_protected_method_defined(:protected_test_method) }
-            it { expect(TestClass).to be_private_method_defined(:private_test_method) }
+    before do
+      TestClass.class_eval do
+        StrangeDecorator()
+        StrangeDecorator()
+        def test_method
+          5
         end
+      end
     end
 
-    context 'when decorator is defining a method during initialization' do
-        before {
-            stub_class(:StrangeDecorator, inherits: [::Decors::DecoratorBase]) {
-                def initialize(decorated_class, undecorated_method, 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 }
+    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 do
+      Spy.class_eval do
+        @ordered_calls = []
+
+        class << self
+          attr_reader :ordered_calls
+
+          def calling(name)
+            ordered_calls << name
+          end
+        end
+      end
+
+      stub_class(:Deco1, inherits: [::Decors::DecoratorBase]) do
+        def call(*)
+          Spy.calling(:deco1_before)
+          super
+          Spy.calling(:deco1_after)
+        end
+      end
+
+      stub_class(:Deco2, inherits: [::Decors::DecoratorBase]) do
+        def call(*)
+          Spy.calling(:deco2_before)
+          super
+          Spy.calling(:deco2_after)
+        end
+      end
+
+      TestClass.class_eval do
+        define_decorator :Deco1, Deco1
+        define_decorator :Deco2, Deco2
+
+        Deco2()
+        Deco1()
+        def test_method(*)
+          Spy.calling(:inside)
+        end
+      end
     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] }
+    before { TestClass.new.test_method }
+    it { expect(Spy.ordered_calls).to eq %i[deco2_before deco1_before inside deco1_after deco2_after] }
+  end
+
+  context 'when method has return value' do
+    before do
+      stub_class(:ModifierDeco, inherits: [::Decors::DecoratorBase])
+
+      TestClass.class_eval do
+        define_decorator :ModifierDeco, ModifierDeco
+
+        ModifierDeco()
+        def test_method
+          :ok
+        end
+      end
     end
 
-    context 'when method has return value' do
-        before {
-            stub_class(:ModifierDeco, inherits: [::Decors::DecoratorBase])
+    it { expect(TestClass.new.test_method).to eq :ok }
+  end
 
-            TestClass.class_eval {
-                define_decorator :ModifierDeco, ModifierDeco
+  context 'when method has arguments' do
+    before do
+      stub_class(:ModifierDeco, inherits: [::Decors::DecoratorBase])
 
-                ModifierDeco()
-                def test_method
-                    :ok
-                end
-            }
-        }
+      TestClass.class_eval do
+        define_decorator :ModifierDeco, ModifierDeco
 
-        it { expect(TestClass.new.test_method).to eq :ok }
+        ModifierDeco()
+        def test_method(*args, **kwargs, &block)
+          Spy.passed_args(*args, **kwargs, &block)
+        end
+      end
     end
 
-    context 'when method has arguments' do
-        before {
-            stub_class(:ModifierDeco, inherits: [::Decors::DecoratorBase])
+    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
 
-            TestClass.class_eval {
-                define_decorator :ModifierDeco, ModifierDeco
+  context 'when changing arguments given to the method' do
+    before do
+      stub_class(:ModifierDeco, inherits: [::Decors::DecoratorBase]) do
+        def call(instance, *)
+          undecorated_call(instance, 1, 2, 3, a: :a, &proc { 'yay' })
+        end
+      end
 
-                ModifierDeco()
-                def test_method(*args, &block)
-                    Spy.passed_args(*args, &block)
-                end
-            }
-        }
+      TestClass.class_eval do
+        define_decorator :ModifierDeco, ModifierDeco
 
-        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' } }
+        ModifierDeco()
+        def test_method(*args, **kwargs, &block)
+          Spy.passed_args(*args, **kwargs, &block)
+        end
+      end
     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 }
+    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 do
+      stub_class(:AddOneToArg, inherits: [::Decors::DecoratorBase]) do
+        def call(instance, *args)
+          undecorated_call(instance, args.first + 1)
+        end
+      end
+
+      TestClass.class_eval do
+        define_decorator :AddOneToArg, AddOneToArg
+
+        AddOneToArg()
+        def test_method(n)
+          return 0 if n.zero?
+
+          n + test_method(n - 2)
+        end
+      end
+    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 do
+      stub_module(:TestMixin) do
+        def method_added(*)
+          Spy.called
+        end
+      end
+      stub_class(:Deco, inherits: [::Decors::DecoratorBase])
     end
+    it { expect(Spy).to receive(:called) }
 
-    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 }
+    after do
+      TestClass.class_eval do
+        extend TestMixin
+
+        define_decorator :Deco, Deco
+
+        def test_method; end
+      end
     end
+  end
+
+  context 'when inherited' do
+    before do
+      stub_class(:Deco, inherits: [::Decors::DecoratorBase])
 
-    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
-            }
-        }
+      TestClass.class_eval do
+        define_decorator :Deco, Deco
+
+        Deco()
+        def test_method
+          :ok
+        end
+      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'
-        }
+    it {
+      stub_class(:TestClass2, inherits: [TestClass])
+      TestClass2.class_eval do
+        Deco()
+        def test_method
+          :ko
+        end
+      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 do
+        Deco()
+        def test_method
+          "this is #{super}"
+        end
+      end
+
+      expect(TestClass3.new.test_method).to eq 'this is ok'
+    }
+  end
+
+  context 'when decorating a class method' do
+    before do
+      stub_class(:Deco, inherits: [::Decors::DecoratorBase]) do
+        def call(*)
+          super
+          Spy.called
+        end
+      end
     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 }
+    context 'when mixin extended on the class (singleton method in class)' do
+      before do
+        TestClass.class_eval do
+          define_decorator :Deco, Deco
+
+          Deco()
+          def self.test_method
+            :ok
+          end
         end
+      end
 
-        context 'when mixin extended on the class (singleton method in singleton class)' do
-            before {
-                TestClass.class_eval {
-                    class << self
-                        extend Decors::DecoratorDefinition
+      it { expect(Spy).to receive(:called) }
+      after { TestClass.test_method }
+    end
 
-                        define_decorator :Deco, Deco
+    context 'when mixin extended on the class (singleton method in singleton class)' do
+      before do
+        TestClass.class_eval do
+          class << self
+            extend Decors::DecoratorDefinition
 
-                        Deco()
-                        def self.test_method
-                            :ok
-                        end
-                    end
-                }
-            }
+            define_decorator :Deco, Deco
 
-            it { expect(Spy).to receive(:called) }
-            after { TestClass.singleton_class.test_method }
+            Deco()
+            def self.test_method
+              :ok
+            end
+            end
         end
+      end
+
+      it { expect(Spy).to receive(:called) }
+      after { TestClass.singleton_class.test_method }
+    end
 
-        context 'when mixin extended on the class (method in singleton class of singleton class)' do
-            before {
-                TestClass.class_eval {
-                    class << self
-                        class << self
-                            extend Decors::DecoratorDefinition
-
-                            define_decorator :Deco, Deco
-
-                            Deco()
-                            def test_method
-                                :ok
-                            end
-                        end
-                    end
-                }
-            }
-
-            it { expect(Spy).to receive(:called) }
-            after { TestClass.singleton_class.test_method }
+    context 'when mixin extended on the class (method in singleton class of singleton class)' do
+      before do
+        TestClass.class_eval do
+          class << self
+            class << self
+              extend Decors::DecoratorDefinition
+
+              define_decorator :Deco, Deco
+
+              Deco()
+              def test_method
+                :ok
+              end
+            end
+            end
         end
+      end
 
-        context 'when mixin extended on the class (method in singleton class)' do
-            before {
-                TestClass.class_eval {
-                    class << self
-                        extend Decors::DecoratorDefinition
+      it { expect(Spy).to receive(:called) }
+      after { TestClass.singleton_class.test_method }
+    end
 
-                        define_decorator :Deco, Deco
+    context 'when mixin extended on the class (method in singleton class)' do
+      before do
+        TestClass.class_eval do
+          class << self
+            extend Decors::DecoratorDefinition
 
-                        Deco()
-                        def test_method
-                            :ok
-                        end
-                    end
-                }
-            }
+            define_decorator :Deco, Deco
 
-            it { expect(Spy).to receive(:called) }
-            after { TestClass.test_method }
+            Deco()
+            def test_method
+              :ok
+            end
+            end
         end
+      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
+      it { expect(Spy).to receive(:called) }
+      after { TestClass.test_method }
+    end
 
-                    Deco()
-                    def self.test_method__in_class
-                        :ok
-                    end
+    context 'when mixin extended on the class (both method in singleton class and singleton method in class)' do
+      before do
+        TestClass.class_eval do
+          define_decorator :Deco, Deco
 
-                    def self.untest_method__in_class
-                    end
+          Deco()
+          def self.test_method__in_class
+            :ok
+          end
 
-                    class << self
-                        extend Decors::DecoratorDefinition
+          def self.untest_method__in_class; end
 
-                        define_decorator :Deco, Deco
+          class << self
+            extend Decors::DecoratorDefinition
 
-                        Deco()
-                        def test_method__in_singleton
-                            :ok
-                        end
+            define_decorator :Deco, Deco
 
-                        def untest_method__in_singleton
-                        end
-                    end
-                }
-            }
+            Deco()
+            def test_method__in_singleton
+              :ok
+            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 }
+            def untest_method__in_singleton; end
+          end
         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