aspectual 0.1.1 → 0.9.0

data/spec/lib/aspectual_spec.rb

@@ -1,221 +1,284 @@
+# frozen_string_literal: true
+
 require_relative '../../lib/aspectual'
 
-describe Aspectual do
-  class TestClass
-    extend Aspectual
+class TestClass
+  extend Aspectual
 
-    attr_reader :methods_called
+  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 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"
-      self
-    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'
+    self
+  end
 
-    def array_test_method_0
-      methods_called << "array_test_method_0"
-      self
-    end
+  def array_test_method_0
+    methods_called << 'array_test_method_0'
+    self
+  end
 
-    def array_test_method_1
-      methods_called << "array_test_method_1"
-      self
-    end
+  def array_test_method_1
+    methods_called << 'array_test_method_1'
+    self
+  end
 
-    def before_test_method_0
-      methods_called << "before_test_method_0"
-      self
-    end
+  def before_test_method_0
+    methods_called << 'before_test_method_0'
+    self
+  end
 
-    def before_test_method_1
-      methods_called << "before_test_method_1"
-      self
-    end
+  def before_test_method_1
+    methods_called << 'before_test_method_1'
+    self
+  end
 
-    def after_test_method_0
-      methods_called << "after_test_method_0"
-      self
-    end
+  def after_test_method_0
+    methods_called << 'after_test_method_0'
+    self
+  end
 
-    def after_test_method_1
-      methods_called << "after_test_method_1"
-      self
-    end
+  def after_test_method_1
+    methods_called << 'after_test_method_1'
+    self
+  end
 
-    def block_test_method_0
-      methods_called << "before_block_test_method_0_block"
-      yield
-      methods_called << "after_block_test_method_0_block"
-      self
-    end
+  def block_test_method_0
+    methods_called << 'before_block_test_method_0_block'
+    yield
+    methods_called << 'after_block_test_method_0_block'
+    self
+  end
 
-    def block_test_method_1
-      methods_called << "before_block_test_method_1_block"
-      yield
-      methods_called << "after_block_test_method_1_block"
-      self
-    end
+  def block_test_method_1
+    methods_called << 'before_block_test_method_1_block'
+    yield
+    methods_called << 'after_block_test_method_1_block'
+    self
+  end
 
-    aspects before: :single_test_method
-    def single_before_test_method
-      methods_called << "single_before_test_method"
-      self
-    end
+  aspects before: :single_test_method
+  def single_before_test_method
+    methods_called << 'single_before_test_method'
+    self
+  end
 
-    aspects around: :block_test_method_0
-    def single_around_test_method
-      methods_called << "single_around_test_method"
-      self
-    end
+  aspects around: :block_test_method_0
+  def single_around_test_method
+    methods_called << 'single_around_test_method'
+    self
+  end
 
-    aspects after: :single_test_method
-    def single_after_test_method
-      methods_called << "single_after_test_method"
-      self
-    end
+  aspects after: :single_test_method
+  def single_after_test_method
+    methods_called << 'single_after_test_method'
+    self
+  end
 
-    aspects before: [:array_test_method_0, :array_test_method_1]
-    def array_before_test_method
-      methods_called << "array_before_test_method"
-      self
-    end
+  aspects before: %i[array_test_method_0 array_test_method_1]
+  def array_before_test_method
+    methods_called << 'array_before_test_method'
+    self
+  end
 
-    aspects around: [:block_test_method_0, :block_test_method_1]
-    def array_around_test_method
-      methods_called << "array_around_test_method"
-      self
-    end
+  aspects before: :array_test_method_0
+  aspects before: :array_test_method_1
+  def multiple_before_test_method
+    methods_called << 'multiple_before_test_method'
+    self
+  end
 
-    aspects after: [:array_test_method_0, :array_test_method_1]
-    def array_after_test_method
-      methods_called << "array_after_test_method"
-      self
-    end
+  def specific_before_test_method
+    methods_called << 'specific_before_test_method'
+    self
+  end
+  aspects :specific_before_test_method, before: :single_test_method
 
-    aspects before: [:before_test_method_0, :before_test_method_1], after: [:after_test_method_0, :after_test_method_1]
-    def before_and_after_aspects_test_method
-      methods_called << "before_and_after_aspects_test_method"
-      self
-    end
+  aspects around: %i[block_test_method_0 block_test_method_1]
+  def array_around_test_method
+    methods_called << 'array_around_test_method'
+    self
+  end
 
-    def public_aspect_method
-      methods_called << "public_aspect_method"
-      self
-    end
+  aspects around: :block_test_method_0
+  aspects around: :block_test_method_1
+  def multiple_around_test_method
+    methods_called << 'multiple_around_test_method'
+    self
+  end
 
-    protected
-    aspects before: :public_aspect_method
-    def protected_method
-      methods_called << "protected_method"
-      self
-    end
+  def specific_around_test_method
+    methods_called << 'specific_around_test_method'
+    self
+  end
+  aspects :specific_around_test_method, around: :block_test_method_0
 
-    private
-    aspects before: :public_aspect_method
-    def private_method
-      methods_called << "private_method"
-      self
-    end
+  aspects after: %i[array_test_method_0 array_test_method_1]
+  def array_after_test_method
+    methods_called << 'array_after_test_method'
+    self
+  end
+
+  aspects after: :array_test_method_0
+  aspects after: :array_test_method_1
+  def multiple_after_test_method
+    methods_called << 'multiple_after_test_method'
+    self
+  end
+
+  def specific_after_test_method
+    methods_called << 'specific_after_test_method'
+    self
+  end
+  aspects :specific_after_test_method, after: :single_test_method
+
+  aspects(
+    before: %i[before_test_method_0 before_test_method_1],
+    around: %i[block_test_method_0 block_test_method_1],
+    after: %i[after_test_method_0 after_test_method_1],
+  )
+  def before_around_and_after_aspects_test_method
+    methods_called << 'before_around_and_after_aspects_test_method'
+    self
   end
+end
 
-  describe "before aspects" do
-    it "calls before aspect methods before the called method" do
+describe Aspectual do
+  describe 'before aspects' do
+    it 'calls before aspect methods before the called method' do
       test_instance = TestClass.new.single_before_test_method
-      expect(test_instance.methods_called).to eq(%w{
-        single_test_method
-        single_before_test_method
-      })
+      expect(test_instance.methods_called).to eq(%w[
+                                                   single_test_method
+                                                   single_before_test_method
+                                                 ])
     end
 
-    it "allows multiple aspects to be declared" do
+    it 'can be defined for a specific method' do
+      test_instance = TestClass.new.specific_before_test_method
+      expect(test_instance.methods_called).to eq(%w[
+                                                   single_test_method
+                                                   specific_before_test_method
+                                                 ])
+    end
+
+    it 'allows multiple aspects to be declared' do
       test_instance = TestClass.new.array_before_test_method
-      expect(test_instance.methods_called).to eq(%w{
-        array_test_method_0
-        array_test_method_1
-        array_before_test_method
-      })
+      expect(test_instance.methods_called).to eq(%w[
+                                                   array_test_method_0
+                                                   array_test_method_1
+                                                   array_before_test_method
+                                                 ])
+    end
+
+    it 'allows multiple aspects to be declared in separate calls' do
+      test_instance = TestClass.new.multiple_before_test_method
+      expect(test_instance.methods_called).to eq(%w[
+                                                   array_test_method_0
+                                                   array_test_method_1
+                                                   multiple_before_test_method
+                                                 ])
     end
   end
 
-  describe "after aspects" do
-    it "calls before aspect methods before the called method" do
+  describe 'after aspects' do
+    it 'calls before aspect methods before the called method' do
       test_instance = TestClass.new.single_after_test_method
-      expect(test_instance.methods_called).to eq(%w{
-        single_after_test_method
-        single_test_method
-      })
+      expect(test_instance.methods_called).to eq(%w[
+                                                   single_after_test_method
+                                                   single_test_method
+                                                 ])
     end
 
-    it "allows multiple aspects to be declared" do
-      test_instance = TestClass.new.array_after_test_method
-      expect(test_instance.methods_called).to eq(%w{
-        array_after_test_method
-        array_test_method_0
-        array_test_method_1
-      })
+    it 'can be defined for a specific method' do
+      test_instance = TestClass.new.specific_after_test_method
+      expect(test_instance.methods_called).to eq(%w[
+                                                   specific_after_test_method
+                                                   single_test_method
+                                                 ])
     end
-  end
 
-  describe "around aspects" do
-    it "calls around aspect methods around the called method" do
-      test_instance = TestClass.new.single_around_test_method
-      expect(test_instance.methods_called).to eq(%w{
-        before_block_test_method_0_block
-        single_around_test_method
-        after_block_test_method_0_block
-      })
+    it 'allows multiple aspects to be declared' do
+      test_instance = TestClass.new.array_after_test_method
+      expect(test_instance.methods_called).to eq(%w[
+                                                   array_after_test_method
+                                                   array_test_method_0
+                                                   array_test_method_1
+                                                 ])
     end
 
-    it "allows multiple aspects to be declared" do
-      test_instance = TestClass.new.array_around_test_method
-      expect(test_instance.methods_called).to eq(%w{
-        before_block_test_method_0_block
-        before_block_test_method_1_block
-        array_around_test_method
-        after_block_test_method_1_block
-        after_block_test_method_0_block
-      })
+    it 'allows multiple aspects to be declared in separate calls' do
+      test_instance = TestClass.new.multiple_after_test_method
+      expect(test_instance.methods_called).to eq(%w[
+                                                   multiple_after_test_method
+                                                   array_test_method_0
+                                                   array_test_method_1
+                                                 ])
     end
   end
 
-  describe "mixed aspects" do
-    it "calls all the aspect declarations in the correct order" do
-      test_instance = TestClass.new.before_and_after_aspects_test_method
-      expect(test_instance.methods_called).to eq(%w{
-        before_test_method_0
-        before_test_method_1
-        before_and_after_aspects_test_method
-        after_test_method_0
-        after_test_method_1
-      })
+  describe 'around aspects' do
+    it 'calls around aspect methods around the called method' do
+      test_instance = TestClass.new.single_around_test_method
+      expect(test_instance.methods_called).to eq(%w[
+                                                   before_block_test_method_0_block
+                                                   single_around_test_method
+                                                   after_block_test_method_0_block
+                                                 ])
     end
-  end
 
-  describe "public methods" do
-    it "stay public" do
-      test_instance = TestClass.new.single_before_test_method
-      expect(test_instance.public_methods).to include(:single_before_test_method)
+    it 'can be defined for a specific method' do
+      test_instance = TestClass.new.specific_around_test_method
+      expect(test_instance.methods_called).to eq(%w[
+                                                   before_block_test_method_0_block
+                                                   specific_around_test_method
+                                                   after_block_test_method_0_block
+                                                 ])
+    end
+
+    it 'allows multiple aspects to be declared' do
+      test_instance = TestClass.new.array_around_test_method
+      expect(test_instance.methods_called).to eq(%w[
+                                                   before_block_test_method_0_block
+                                                   before_block_test_method_1_block
+                                                   array_around_test_method
+                                                   after_block_test_method_1_block
+                                                   after_block_test_method_0_block
+                                                 ])
     end
-  end
 
-  describe "protected methods" do
-    it "stay protected" do
-      test_instance = TestClass.new
-      expect(test_instance.protected_methods).to include(:protected_method)
+    it 'allows multiple aspects to be declared in separate calls' do
+      test_instance = TestClass.new.multiple_around_test_method
+      expect(test_instance.methods_called).to eq(%w[
+                                                   before_block_test_method_0_block
+                                                   before_block_test_method_1_block
+                                                   multiple_around_test_method
+                                                   after_block_test_method_1_block
+                                                   after_block_test_method_0_block
+                                                 ])
     end
   end
 
-  describe "private methods" do
-    it "stay private" do
-      test_instance = TestClass.new
-      expect(test_instance.private_methods).to include(:private_method)
+  describe 'mixed aspects' do
+    it 'calls all the aspect declarations in the correct order' do
+      test_instance = TestClass.new.before_around_and_after_aspects_test_method
+      expect(test_instance.methods_called).to eq(%w[
+                                                   before_test_method_0
+                                                   before_test_method_1
+                                                   before_block_test_method_0_block
+                                                   before_block_test_method_1_block
+                                                   before_around_and_after_aspects_test_method
+                                                   after_block_test_method_1_block
+                                                   after_block_test_method_0_block
+                                                   after_test_method_0
+                                                   after_test_method_1
+                                                 ])
     end
   end
 end

metadata

@@ -1,57 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: aspectual
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.9.0
 platform: ruby
 authors:
-- Alex Sunderland
-autorequire: 
+- Fell Sunderland
 bindir: bin
 cert_chain: []
-date: 2014-12-27 00:00:00.000000000 Z
-dependencies:
-- !ruby/object:Gem::Dependency
-  name: bundler
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: rake
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: 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'
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
 description: "\n    A simple gem to support minimal Aspect Oriented Programming in
   ruby.\n  "
 email:
@@ -60,18 +17,30 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".github/workflows/rubocop.yml"
+- ".github/workflows/ruby.yml"
 - ".gitignore"
+- ".rubocop.yml"
 - Gemfile
 - README.md
 - aspectual.gemspec
 - lib/aspectual.rb
+- lib/aspectual/method_construction.rb
 - lib/aspectual/version.rb
+- spec/lib/aspectual_block_args_spec.rb
+- spec/lib/aspectual_complex_args_spec.rb
+- spec/lib/aspectual_inheritance_spec.rb
+- spec/lib/aspectual_kwargs_spec.rb
+- spec/lib/aspectual_non_word_ending_character_spec.rb
+- spec/lib/aspectual_positional_args_spec.rb
+- spec/lib/aspectual_return_value_spec.rb
+- spec/lib/aspectual_scoping_spec.rb
 - spec/lib/aspectual_spec.rb
 homepage: https://github.com/AgentAntelope/aspectual
 licenses:
 - MIT
-metadata: {}
-post_install_message: 
+metadata:
+  rubygems_mfa_required: 'true'
 rdoc_options: []
 require_paths:
 - lib
@@ -79,17 +48,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '3.1'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.4.5
-signing_key: 
+rubygems_version: 4.0.15
 specification_version: 4
 summary: A gem to help with AOP.
-test_files:
-- spec/lib/aspectual_spec.rb
+test_files: []