aspectual 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5e0539219c7424a96ef89cc5e2b1e282de09f628
-  data.tar.gz: 0fd69a69034f8a5b7e14cb336a0252b61355dc03
+  metadata.gz: 791be340bcb932e339d64f0735635b806b0ed860
+  data.tar.gz: e85f88a62334e97d685f2d626d7d9e7b8a45c8ff
 SHA512:
-  metadata.gz: d4ad4996acbfcecbbe2ed8079629f837befe16e77f99610fb97ab20ab7f010792dd663940453ddbde0829782e24f1f8d623dce35477223d79d56efa111599136
-  data.tar.gz: 2ea04111ca09aea033b3aa5f0fe1e5290744853c1a76fd89a9f9ff82b0f02c0f7d3b92317afc6e13809585e6c575ea98fd6a15f324db8af66bb4cd78c8d1a1bb
+  metadata.gz: d20e5e8d7ec23d34f6664626248f49e29276f2cb963383f19579bc6300e8182ce791eccc639d8d8bda12e3929f3aa3210d807504a3c96e3170001da86ccf07dc
+  data.tar.gz: c5dd639e0b3fa4f1e187fc445ba6682aef248a100bc99453e6e6d61a657c34284e6cf2edd2f9723e9390798ea21bcfd81f329f2a8c37f1f6d34fb729f64da7ef

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in overload.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,27 @@
+PATH
+  remote: .
+  specs:
+    aspectual (0.0.2)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    diff-lcs (1.2.5)
+    rake (10.3.1)
+    rspec (2.14.1)
+      rspec-core (~> 2.14.0)
+      rspec-expectations (~> 2.14.0)
+      rspec-mocks (~> 2.14.0)
+    rspec-core (2.14.8)
+    rspec-expectations (2.14.5)
+      diff-lcs (>= 1.1.3, < 2.0)
+    rspec-mocks (2.14.6)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  aspectual!
+  bundler (~> 1.3)
+  rake
+  rspec

data/README.md

@@ -0,0 +1,47 @@
+[![Gem Version](https://badge.fury.io/rb/aspectual.png)](http://badge.fury.io/rb/aspectual)
+
+# Aspectual
+
+A simple gem to support minimal Aspect Oriented Programming in ruby.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'aspectual'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install aspectual
+
+## Usage
+
+Extend the module
+
+    extend Aspectual
+
+Create any methods you want as aspects (Aspectual will not add methods you don't have as aspects)
+
+Then declare your aspects
+
+    aspects before: :logging, after: :more_logging
+    def foo
+      "foo"
+    end
+
+    aspects before: [:notify_user, :notify_admin], after: [:remove_temp_files, :play_sound]
+    def bar
+      "bar"
+    end
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/aspectual.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'aspectual/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "aspectual"
+  spec.version       = Aspectual::VERSION
+  spec.authors       = ["Alex Sunderland"]
+  spec.email         = ["agentantelope+aspectual@gmail.com"]
+  spec.description   = %q{
+    A simple gem to support minimal Aspect Oriented Programming in ruby.
+  }
+  spec.summary       = %q{A gem to help with AOP.}
+  spec.homepage      = "https://github.com/AgentAntelope/aspectual"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+end

data/lib/aspectual/version.rb

@@ -0,0 +1,3 @@
+module Aspectual
+  VERSION = '0.0.2'
+end

data/lib/aspectual.rb

@@ -0,0 +1,82 @@
+#!/usr/bin/env ruby
+
+module Aspectual
+  def aspects(aspects)
+    # The before aspect have to be reversed so that when multiple before
+    # aspects are added to one method, the first declared method will be
+    # added last.
+    @_before_aspects = Array(aspects[:before]).reverse
+    @_after_aspects  = Array(aspects[:after])
+  end
+
+  def method_added(method_symbol)
+    return unless has_aspects_declared?
+    return if @_defining_method
+    if method_defined?(method_symbol)
+
+      %w{before after}.each do |position|
+        current_aspects = instance_variable_get("@_#{position}_aspects")
+        if current_aspects
+          current_aspects.each do |aspect|
+            define_aspect_method(method_symbol, position, aspect)
+          end
+        end
+      end
+    end
+  end
+
+  private
+
+  def has_aspects_declared?
+    @_before_aspects || @_after_aspects
+  end
+
+  def define_aspect_method(method_symbol, position, aspect)
+    # This is to prevent us from looping because we're about to define some methods.
+    @_defining_method = true
+
+    with_aspect_method_name = method_symbol.to_s + "_with_#{position}_" + aspect.to_s
+    without_aspect_method_name = method_symbol.to_s + "_without_#{position}_" + aspect.to_s
+
+    case position
+    when "after"
+      aspect_proc = lambda {|*args| send(without_aspect_method_name, *args); send(aspect, *args)}
+    when "before"
+      aspect_proc = lambda {|*args| send(aspect, *args); send(without_aspect_method_name, *args)}
+    end
+
+    define_method(with_aspect_method_name, aspect_proc)
+
+    scope_method_to_parent(method_symbol, with_aspect_method_name)
+
+    alias_method_chain(method_symbol, aspect.to_sym, position)
+
+    @_defining_method = false
+  end
+
+  def scope_method_to_parent(without_method, target)
+    case
+    when public_method_defined?(without_method)
+      public target
+    when protected_method_defined?(without_method)
+      protected target
+    when private_method_defined?(without_method)
+      private target
+    end
+  end
+
+  # adapted from active support
+  def alias_method_chain(target, feature, position)
+    # Strip out punctuation on predicates or bang methods since
+    # e.g. target?_without_position_feature is not a valid method name.
+    aliased_target, punctuation = target.to_s.sub(/([?!=])$/, ''), $1
+
+    with_method = "#{aliased_target}_with_#{position}_#{feature}#{punctuation}"
+    without_method = "#{aliased_target}_without_#{position}_#{feature}#{punctuation}"
+
+    alias_method without_method, target
+    alias_method target, with_method
+
+    scope_method_to_parent(without_method, target)
+  end
+end

data/spec/lib/aspectual_spec.rb

@@ -0,0 +1,173 @@
+require_relative '../../lib/aspectual'
+
+describe Aspectual do
+  class TestClass
+    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"
+      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 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 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
+
+    aspects before: :single_test_method
+    def single_before_test_method
+      methods_called << "single_before_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 after: [:array_test_method_0, :array_test_method_1]
+    def array_after_test_method
+      methods_called << "array_after_test_method"
+      self
+    end
+
+    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
+
+    def public_aspect_method
+      methods_called << "public_aspect_method"
+      self
+    end
+
+    protected
+    aspects before: :public_aspect_method
+    def protected_method
+      methods_called << "protected_method"
+      self
+    end
+
+    private
+    aspects before: :public_aspect_method
+    def private_method
+      methods_called << "private_method"
+      self
+    end
+  end
+
+  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 match_array(%w{
+        single_test_method
+        single_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 match_array(%w{
+        array_test_method_0
+        array_test_method_1
+        array_before_test_method
+      })
+    end
+  end
+
+  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 match_array(%w{
+        single_test_method
+        single_after_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 match_array(%w{
+        array_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 match_array(%w{
+        before_test_method_0
+        before_test_method_1
+        before_and_after_aspects_test_method
+        after_test_method_0
+        after_test_method_1
+      })
+    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)
+    end
+  end
+
+  describe "protected methods" do
+    it "stay protected" do
+      test_instance = TestClass.new
+      expect(test_instance.protected_methods).to include(:protected_method)
+    end
+  end
+
+  describe "private methods" do
+    it "stay private" do
+      test_instance = TestClass.new
+      expect(test_instance.private_methods).to include(:private_method)
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: aspectual
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Alex Sunderland
@@ -59,8 +59,16 @@ email:
 executables: []
 extensions: []
 extra_rdoc_files: []
-files: []
-homepage: ''
+files:
+- Gemfile
+- Gemfile.lock
+- README.md
+- aspectual-0.0.1.gem
+- aspectual.gemspec
+- lib/aspectual.rb
+- lib/aspectual/version.rb
+- spec/lib/aspectual_spec.rb
+homepage: https://github.com/AgentAntelope/aspectual
 licenses:
 - MIT
 metadata: {}
@@ -84,4 +92,5 @@ rubygems_version: 2.0.6
 signing_key: 
 specification_version: 4
 summary: A gem to help with AOP.
-test_files: []
+test_files:
+- spec/lib/aspectual_spec.rb