aspectual 0.1.1 → 0.9.0

data/spec/lib/aspectual_kwargs_spec.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require_relative '../../lib/aspectual'
+
+class KwargsTestClass
+  extend Aspectual
+
+  attr_reader :methods_called
+
+  def initialize
+    # This is to ensure that all methods are properly called within the
+    # context of the current instance of this object.
+    @methods_called = []
+  end
+
+  def kwarg_aspect_method(**kwargs)
+    methods_called << "kwarg_aspect_method_kwargs_#{kwargs.to_a.join('_')}"
+    self
+  end
+
+  def kwarg_around_aspect_method(**kwargs)
+    methods_called << "before_block_kwarg_around_aspect_method_kwargs_#{kwargs.to_a.join('_')}"
+    yield
+    methods_called << "after_block_kwarg_around_aspect_method_kwargs_#{kwargs.to_a.join('_')}"
+    self
+  end
+
+  aspects before: :kwarg_aspect_method
+  def before_kwarg_test_method(**kwargs)
+    methods_called << "before_kwarg_test_method_kwargs_#{kwargs.to_a.join('_')}"
+    self
+  end
+
+  aspects around: :kwarg_around_aspect_method
+  def around_kwarg_test_method(**kwargs)
+    methods_called << "around_kwarg_test_method_kwargs_#{kwargs.to_a.join('_')}"
+    self
+  end
+
+  aspects after: :kwarg_aspect_method
+  def after_kwarg_test_method(**kwargs)
+    methods_called << "after_kwarg_test_method_kwargs_#{kwargs.to_a.join('_')}"
+    self
+  end
+end
+
+describe Aspectual do
+  describe 'methods with kwarg arguments' do
+    it 'can handle before aspects' do
+      test_instance = KwargsTestClass.new.before_kwarg_test_method(kwarg_1: :val_1, kwarg_2: :val_2)
+      expect(test_instance.methods_called).to eq(
+        %w[
+          kwarg_aspect_method_kwargs_kwarg_1_val_1_kwarg_2_val_2
+          before_kwarg_test_method_kwargs_kwarg_1_val_1_kwarg_2_val_2
+        ],
+      )
+    end
+
+    it 'can handle around aspects' do
+      test_instance = KwargsTestClass.new.around_kwarg_test_method(kwarg_1: :val_1, kwarg_2: :val_2)
+      expect(test_instance.methods_called).to eq(
+        %w[
+          before_block_kwarg_around_aspect_method_kwargs_kwarg_1_val_1_kwarg_2_val_2
+          around_kwarg_test_method_kwargs_kwarg_1_val_1_kwarg_2_val_2
+          after_block_kwarg_around_aspect_method_kwargs_kwarg_1_val_1_kwarg_2_val_2
+        ],
+      )
+    end
+
+    it 'can handle after aspects' do
+      test_instance = KwargsTestClass.new.after_kwarg_test_method(kwarg_1: :val_1, kwarg_2: :val_2)
+      expect(test_instance.methods_called).to eq(
+        %w[
+          after_kwarg_test_method_kwargs_kwarg_1_val_1_kwarg_2_val_2
+          kwarg_aspect_method_kwargs_kwarg_1_val_1_kwarg_2_val_2
+        ],
+      )
+    end
+  end
+end

data/spec/lib/aspectual_non_word_ending_character_spec.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+require_relative '../../lib/aspectual'
+
+class NonWordEndingCharacterTestClass
+  extend Aspectual
+
+  attr_reader :methods_called
+
+  def initialize
+    # This is to ensure that all methods are properly called within the
+    # context of the current instance of this object.
+    @methods_called = []
+  end
+
+  def predicate_aspect_method?
+    methods_called << 'predicate_aspect_method?'
+    self
+  end
+
+  aspects before: :predicate_aspect_method?
+  def predicate_test_method
+    methods_called << 'predicate_test_method'
+    self
+  end
+
+  aspects before: :predicate_aspect_method?
+  def predicate_test_method?
+    methods_called << 'predicate_test_method?'
+    self
+  end
+
+  def bang_aspect_method!
+    methods_called << 'bang_aspect_method!'
+    self
+  end
+
+  aspects before: :bang_aspect_method!
+  def bang_test_method
+    methods_called << 'bang_test_method'
+    self
+  end
+
+  aspects before: :bang_aspect_method!
+  def bang_test_method!
+    methods_called << 'bang_test_method!'
+    self
+  end
+
+  def assign_aspect_method=
+    methods_called << 'assign_aspect_method='
+  end
+
+  aspects before: :assign_aspect_method=
+  def assign_test_method
+    methods_called << 'assign_test_method'
+    self
+  end
+
+  aspects before: :assign_aspect_method=
+  def assign_test_method=
+    methods_called << 'assign_test_method='
+  end
+end
+
+describe Aspectual do
+  describe 'methods ending in non-standard characters' do
+    describe 'predicate methods' do
+      it 'can handle predicate aspects' do
+        test_instance = NonWordEndingCharacterTestClass.new
+        test_instance.predicate_test_method
+        expect(test_instance.methods_called).to eq(%w[
+                                                     predicate_aspect_method?
+                                                     predicate_test_method
+                                                   ])
+      end
+
+      it 'can handle predicate methods' do
+        test_instance = NonWordEndingCharacterTestClass.new
+        test_instance.predicate_test_method?
+        expect(test_instance.methods_called).to eq(%w[
+                                                     predicate_aspect_method?
+                                                     predicate_test_method?
+                                                   ])
+      end
+    end
+
+    describe 'bang methods' do
+      it 'can handle bang aspects' do
+        test_instance = NonWordEndingCharacterTestClass.new
+        test_instance.bang_test_method
+        expect(test_instance.methods_called).to eq(%w[
+                                                     bang_aspect_method!
+                                                     bang_test_method
+                                                   ])
+      end
+
+      it 'can handle bang methods' do
+        test_instance = NonWordEndingCharacterTestClass.new
+        test_instance.bang_test_method!
+        expect(test_instance.methods_called).to eq(%w[
+                                                     bang_aspect_method!
+                                                     bang_test_method!
+                                                   ])
+      end
+    end
+
+    describe 'assign methods' do
+      it 'can handle assign aspects' do
+        test_instance = NonWordEndingCharacterTestClass.new
+        test_instance.assign_test_method
+        expect(test_instance.methods_called).to eq(%w[
+                                                     assign_aspect_method=
+                                                     assign_test_method
+                                                   ])
+      end
+
+      it 'can handle assign methods' do
+        test_instance = NonWordEndingCharacterTestClass.new
+        test_instance.send(:assign_test_method=)
+        expect(test_instance.methods_called).to eq(%w[
+                                                     assign_aspect_method=
+                                                     assign_test_method=
+                                                   ])
+      end
+    end
+  end
+end

data/spec/lib/aspectual_positional_args_spec.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require_relative '../../lib/aspectual'
+
+class PositionalArgsTestClass
+  extend Aspectual
+
+  attr_reader :methods_called
+
+  def initialize
+    # This is to ensure that all methods are properly called within the
+    # context of the current instance of this object.
+    @methods_called = []
+  end
+
+  def positional_aspect_method(*args)
+    methods_called << "positional_aspect_method_args_#{args.join('_')}"
+    self
+  end
+
+  def positional_around_aspect_method(*args)
+    methods_called << "before_block_positional_around_aspect_method_args_#{args.join('_')}"
+    yield
+    methods_called << "after_block_positional_around_aspect_method_args_#{args.join('_')}"
+    self
+  end
+
+  aspects before: :positional_aspect_method
+  def before_positional_test_method(*args)
+    methods_called << "before_positional_test_method_args_#{args.join('_')}"
+    self
+  end
+
+  aspects around: :positional_around_aspect_method
+  def around_positional_test_method(*args)
+    methods_called << "before_positional_test_method_args_#{args.join('_')}"
+    self
+  end
+
+  aspects after: :positional_aspect_method
+  def after_positional_test_method(*args)
+    methods_called << "after_positional_test_method_args_#{args.join('_')}"
+    self
+  end
+end
+
+describe Aspectual do
+  describe 'methods with positional arguments' do
+    it 'can handle before aspects' do
+      test_instance = PositionalArgsTestClass.new.before_positional_test_method('arg_1', 'arg_2')
+      expect(test_instance.methods_called).to eq(%w[
+                                                   positional_aspect_method_args_arg_1_arg_2
+                                                   before_positional_test_method_args_arg_1_arg_2
+                                                 ])
+    end
+
+    it 'can handle around aspects' do
+      test_instance = PositionalArgsTestClass.new.around_positional_test_method('arg_1', 'arg_2')
+      expect(test_instance.methods_called).to eq(%w[
+                                                   before_block_positional_around_aspect_method_args_arg_1_arg_2
+                                                   before_positional_test_method_args_arg_1_arg_2
+                                                   after_block_positional_around_aspect_method_args_arg_1_arg_2
+                                                 ])
+    end
+
+    it 'can handle after aspects' do
+      test_instance = PositionalArgsTestClass.new.after_positional_test_method('arg_1', 'arg_2')
+      expect(test_instance.methods_called).to eq(%w[
+                                                   after_positional_test_method_args_arg_1_arg_2
+                                                   positional_aspect_method_args_arg_1_arg_2
+                                                 ])
+    end
+  end
+end

data/spec/lib/aspectual_return_value_spec.rb

@@ -0,0 +1,186 @@
+# frozen_string_literal: true
+
+require_relative '../../lib/aspectual'
+
+class ReturnValueTestClass
+  extend Aspectual
+
+  attr_reader :methods_called
+
+  def initialize
+    # This is to ensure that all methods are properly called within the
+    # context of the current instance of this object.
+    @methods_called = []
+  end
+
+  # These definitions could be looped over to make this class shorter, but the
+  # decision has been made to go for clarity over brevity.
+  def single_test_method
+    methods_called << 'single_test_method'
+    'single_test_method'
+  end
+
+  def array_test_method_0
+    methods_called << 'array_test_method_0'
+    'array_test_method_0'
+  end
+
+  def array_test_method_1
+    methods_called << 'array_test_method_1'
+    'array_test_method_1'
+  end
+
+  def before_test_method_0
+    methods_called << 'before_test_method_0'
+    'before_test_method_0'
+  end
+
+  def before_test_method_1
+    methods_called << 'before_test_method_1'
+    'before_test_method_1'
+  end
+
+  def around_test_method_0
+    methods_called << 'before_block_around_aspect_method_0'
+    yield
+    methods_called << 'after_block_around_aspect_method_0'
+  end
+
+  def around_test_method_1
+    methods_called << 'before_block_around_aspect_method_1'
+    yield
+    methods_called << 'after_block_around_aspect_method_1'
+  end
+
+  def after_test_method_0
+    methods_called << 'after_test_method_0'
+    'after_test_method_0'
+  end
+
+  def after_test_method_1
+    methods_called << 'after_test_method_1'
+    'after_test_method_1'
+  end
+
+  aspects before: :single_test_method
+  def single_before_test_method
+    methods_called << 'single_before_test_method'
+    'single_before_test_method'
+  end
+
+  aspects after: :single_test_method
+  def single_after_test_method
+    methods_called << 'single_after_test_method'
+    'single_after_test_method'
+  end
+
+  aspects before: %i[array_test_method_0 array_test_method_1]
+  def array_before_test_method
+    methods_called << 'array_before_test_method'
+    'array_before_test_method'
+  end
+
+  aspects before: :array_test_method_0
+  aspects before: :array_test_method_1
+  def multiple_before_test_method
+    methods_called << 'multiple_before_test_method'
+    'multiple_before_test_method'
+  end
+
+  def specific_before_test_method
+    methods_called << 'specific_before_test_method'
+    'specific_before_test_method'
+  end
+  aspects :specific_before_test_method, before: :single_test_method
+
+  aspects after: %i[array_test_method_0 array_test_method_1]
+  def array_after_test_method
+    methods_called << 'array_after_test_method'
+    'array_after_test_method'
+  end
+
+  aspects after: :array_test_method_0
+  aspects after: :array_test_method_1
+  def multiple_after_test_method
+    methods_called << 'multiple_after_test_method'
+    'multiple_after_test_method'
+  end
+
+  def specific_after_test_method
+    methods_called << 'specific_after_test_method'
+    'specific_after_test_method'
+  end
+  aspects :specific_after_test_method, after: :single_test_method
+
+  aspects(
+    before: %i[before_test_method_0 before_test_method_1],
+    around: %i[around_test_method_0 around_test_method_1],
+    after: %i[after_test_method_0 after_test_method_1],
+  )
+  def before_and_after_aspects_test_method
+    methods_called << 'before_and_after_aspects_test_method'
+    'before_and_after_aspects_test_method'
+  end
+end
+
+describe Aspectual do
+  describe 'before aspects do not change return value' do
+    it 'calls before aspect methods before the called method' do
+      test_instance = ReturnValueTestClass.new
+      result = test_instance.single_before_test_method
+      expect(result).to eq('single_before_test_method')
+    end
+
+    it 'can be defined for a specific method' do
+      test_instance = ReturnValueTestClass.new
+      result = test_instance.specific_before_test_method
+      expect(result).to eq('specific_before_test_method')
+    end
+
+    it 'allows multiple aspects to be declared' do
+      test_instance = ReturnValueTestClass.new
+      result = test_instance.array_before_test_method
+      expect(result).to eq('array_before_test_method')
+    end
+
+    it 'allows multiple aspects to be declared in separate calls' do
+      test_instance = ReturnValueTestClass.new
+      result = test_instance.multiple_before_test_method
+      expect(result).to eq('multiple_before_test_method')
+    end
+  end
+
+  describe 'after aspects do change return value' do
+    it 'calls before aspect methods before the called method' do
+      test_instance = ReturnValueTestClass.new
+      result = test_instance.single_after_test_method
+      expect(result).to eq('single_test_method')
+    end
+
+    it 'can be defined for a specific method' do
+      test_instance = ReturnValueTestClass.new
+      result = test_instance.specific_after_test_method
+      expect(result).to eq('single_test_method')
+    end
+
+    it 'allows multiple aspects to be declared' do
+      test_instance = ReturnValueTestClass.new
+      result = test_instance.array_after_test_method
+      expect(result).to eq('array_test_method_1')
+    end
+
+    it 'allows multiple aspects to be declared in separate calls' do
+      test_instance = ReturnValueTestClass.new
+      result = test_instance.multiple_after_test_method
+      expect(result).to eq('array_test_method_1')
+    end
+  end
+
+  describe 'mixed aspects' do
+    it 'calls all the aspect declarations in the correct order' do
+      test_instance = ReturnValueTestClass.new
+      result = test_instance.before_and_after_aspects_test_method
+      expect(result).to eq('after_test_method_1')
+    end
+  end
+end

data/spec/lib/aspectual_scoping_spec.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+require_relative '../../lib/aspectual'
+
+class ScopingTestClass
+  extend Aspectual
+
+  attr_reader :methods_called
+
+  def initialize
+    # This is to ensure that all methods are properly called within the
+    # context of the current instance of this object.
+    @methods_called = []
+  end
+
+  def public_aspect_method
+    methods_called << 'public_aspect_method'
+    self
+  end
+
+  aspects before: %i[
+    public_aspect_method
+    protected_aspect_method
+    private_aspect_method
+  ]
+
+  def public_method
+    methods_called << 'public_method'
+    self
+  end
+
+  aspects before: :protected_aspect_method
+  def test_protected_aspect_method
+    methods_called << 'protected_test_method'
+    self
+  end
+
+  aspects before: :private_aspect_method
+  def test_private_aspect_method
+    methods_called << 'private_test_method'
+    self
+  end
+
+  protected
+
+  def protected_aspect_method
+    methods_called << 'protected_aspect_method'
+    self
+  end
+
+  aspects before: %i[
+    public_aspect_method
+    protected_aspect_method
+    private_aspect_method
+  ]
+
+  def protected_method
+    methods_called << 'protected_method'
+    self
+  end
+
+  private
+
+  def private_aspect_method
+    methods_called << 'private_aspect_method'
+    self
+  end
+
+  aspects before: %i[
+    public_aspect_method
+    protected_aspect_method
+    private_aspect_method
+  ]
+
+  def private_method
+    methods_called << 'private_method'
+    self
+  end
+end
+
+describe Aspectual do
+  describe 'public methods' do
+    it 'can have varying accessibility aspects' do
+      test_instance = ScopingTestClass.new.public_method
+      expect(test_instance.methods_called).to eq(%w[
+                                                   public_aspect_method
+                                                   protected_aspect_method
+                                                   private_aspect_method
+                                                   public_method
+                                                 ])
+    end
+
+    it 'stays public' do
+      test_instance = ScopingTestClass.new
+      expect(test_instance.public_methods).to include(:public_method)
+    end
+  end
+
+  describe 'protected methods' do
+    it 'can have varying accessibility aspects' do
+      test_instance = ScopingTestClass.new.send(:protected_method)
+      expect(test_instance.methods_called).to eq(%w[
+                                                   public_aspect_method
+                                                   protected_aspect_method
+                                                   private_aspect_method
+                                                   protected_method
+                                                 ])
+    end
+
+    it 'stays protected' do
+      test_instance = ScopingTestClass.new
+      expect(test_instance.protected_methods).to include(:protected_method)
+    end
+  end
+
+  describe 'private methods' do
+    it 'can have varying accessibility aspects' do
+      test_instance = ScopingTestClass.new.send(:private_method)
+      expect(test_instance.methods_called).to eq(%w[
+                                                   public_aspect_method
+                                                   protected_aspect_method
+                                                   private_aspect_method
+                                                   private_method
+                                                 ])
+    end
+
+    it 'stays private' do
+      test_instance = ScopingTestClass.new
+      expect(test_instance.private_methods).to include(:private_method)
+    end
+  end
+end