aspector 0.13.1 → 0.14.0

data/lib/aspector/logger.rb

@@ -1,63 +1,36 @@
 module Aspector
-  class Logger
-
+  # Default logger for Aspector
+  # @note It uses ::Logger features - providing basic logging
+  class Logger < ::Logger
     attr_reader :context
-    attr_accessor :level
 
-    def initialize context
+    def initialize(context)
+      super(STDOUT)
       @context = context
-
-      if (level_string = ENV['ASPECTOR_LOG_LEVEL'])
-        @level = string_to_level(level_string)
-      else
-        @level = Logging::DEFAULT_VISIBLE_LEVEL
-      end
+      @level = (ENV['ASPECTOR_LOG_LEVEL'] || ::Logger::ERROR).to_i
     end
 
-    def log level, *args
-      return if self.level > level
-
-      puts log_prefix(level) << args.join(" | ")
-    end
-
-    def visible? level
-      self.level <= level
+    %i( debug info warn error fatal ).each do |level|
+      define_method level do |*args|
+        super(nil) { postfix(*args) }
+      end
     end
 
     private
 
-    def log_prefix level
-      s = "#{Time.now} | Aspector | " << level_to_string(level) << " | "
+    def postfix(*args)
+      msg = []
+
       if context.is_a? Aspector::Base
-        s << context.class.to_s << " | " << context.target.to_s << " | "
+        msg << context.class.to_s
+        msg << context.target.to_s
       else
-        s << context.to_s << " | "
+        msg << context.to_s
       end
-    end
 
-    def level_to_string level
-      case level
-      when Logging::ERROR then "ERROR"
-      when Logging::WARN  then "WARN "
-      when Logging::INFO  then "INFO "
-      when Logging::DEBUG then "DEBUG"
-      when Logging::TRACE then "TRACE"
-      else level.to_s
-      end
-    end
+      msg += args
 
-    def string_to_level level_string
-      return Logging::DEFAULT_VISIBLE_LEVEL if level_string.nil? or level_string.strip == ''
-
-      case level_string.downcase
-        when 'error' then Logging::ERROR
-        when 'warn'  then Logging::WARN
-        when 'info'  then Logging::INFO
-        when 'debug' then Logging::DEBUG
-        when 'trace' then Logging::TRACE
-        when 'none'  then Logging::NONE
-      end
+      msg.join(' | ')
     end
   end
 end
-

data/lib/aspector/logging.rb

@@ -1,38 +1,19 @@
 module Aspector
+  # Class used as a wrapper to get logging instances
   module Logging
-    # Log levels
-    NONE  = 10000
-    ERROR = 50
-    WARN  = 40
-    INFO  = 30
-    DEBUG = 20
-    TRACE = 10
-
-    DEFAULT_VISIBLE_LEVEL = INFO
-
-    def self.get_logger context
-      if logger_class_name = ENV["ASPECTOR_LOGGER"]
-        begin
-          logger_class = constanize(logger_class_name)
-          logger_class.new(context)
-        rescue => e
-          $stderr.puts e.message
-
-          Logger.new(context)
-        end
-      else
-        Logger.new(context)
+    class << self
+      def get_logger(context)
+        (deconstantize(ENV['ASPECTOR_LOGGER'] || 'Aspector::Logger')).new(context)
       end
-    end
 
-    private
+      private
 
-    def self.constanize class_name
-      unless /\A(?:::)?([A-Z]\w*(?:::[A-Z]\w*)+)\z/ =~ class_name
-        raise NameError, "#{class_name} is not a valid constant name!"
+      def deconstantize(klass_name)
+        Object.const_get(klass_name.to_s)
+      rescue NameError
+        $stderr.puts "#{klass_name} is not a valid constant name!"
+        Aspector::Logger
       end
-
-      Object.module_eval("::#{$1}", __FILE__, __LINE__)
     end
   end
 end

data/lib/aspector/method_matcher.rb

@@ -1,11 +1,11 @@
 module Aspector
   class MethodMatcher
-    def initialize *match_data
+    def initialize(*match_data)
       @match_data = match_data
       @match_data.flatten!
     end
 
-    def match? method, aspect = nil
+    def match?(method, aspect = nil)
       @match_data.detect do |item|
         case item
         when String
@@ -29,16 +29,15 @@ module Aspector
         end
       end
     end
-    
-    def use_deferred_logic? logic
+
+    def use_deferred_logic?(logic)
       @match_data.detect do |item|
         logic == item
       end
     end
 
     def to_s
-      @match_data.map {|item| item.inspect }.join ", "
+      @match_data.map(&:inspect).join(', ')
     end
   end
 end
-

data/lib/aspector/object_extension.rb

@@ -1,33 +1,25 @@
 module Aspector
   module ObjectExtension
-
     private
 
-    def aspector *args, &block
+    def aspector(*args, &block)
       options = args.last.is_a?(Hash) ? args.pop : {}
 
       aspect = Aspector(options, &block)
 
       aspect.apply(self) if self.is_a? Module
-      args.each {|target| aspect.apply(target) }
+      args.each { |target| aspect.apply(target) }
 
       aspect
     end
 
-    def Aspector options = {}, &block
+    def Aspector(options = {}, &block)
       klass = Class.new(Aspector::Base)
       klass.class_eval { default options }
-      klass.class_eval &block if block_given?
+      klass.class_eval(&block) if block_given?
       klass
     end
-
-    def returns value = nil
-      throw :returns, value
-    end
-    alias :returns :returns
-
   end
 end
 
 Object.send(:include, Aspector::ObjectExtension)
-

data/lib/aspector/version.rb

@@ -0,0 +1,3 @@
+module Aspector
+  VERSION = '0.14.0'
+end

data/spec/examples_spec.rb

@@ -0,0 +1,59 @@
+# This spec will execute all the examples to check if they are working
+# By default all of them should work just fine
+# Note that it won't check if the aspector works in examples as it should
+# This is covered in unit and functional specs - here we check that all examples run
+# without problems
+
+require 'spec_helper'
+require 'stringio'
+
+# Kernel
+module Kernel
+  # Method used to catch the STDIO from all the examples
+  # Examples by default print some stuff to the output - we don't want that
+  # in our specs, thats why we catch it
+  # We're only interested if all examples work as they should (without any errors)
+  def capture_stdout
+    out = StringIO.new
+    $stdout = out
+    yield
+    out
+  ensure
+    $stdout = STDOUT
+  end
+
+  # Same as capture_stdout but to silence stderr
+  def capture_stderr
+    out = StringIO.new
+    $stderr = out
+    yield
+    out
+  ensure
+    $stderr = STDOUT
+  end
+end
+
+RSpec.describe 'Aspector examples' do
+  Dir.glob(
+    File.join(
+      File.dirname(__FILE__),
+      '..',
+      'examples/*.rb'
+    )
+  ).each do |example_file|
+    context "examples file: #{example_file}" do
+      it 'should run without any errors' do
+        capture_stdout do
+          capture_stderr do
+            Process.fork do
+              require example_file
+            end
+          end
+        end
+
+        _pid, status = Process.wait2
+        expect(status.exitstatus).to eq 0
+      end
+    end
+  end
+end

data/spec/functionals/aspect_for_multiple_targets_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+
+RSpec.describe Aspector do
+  let(:klass1) do
+    ClassBuilder.build do
+      def exec1
+        values << 'exec1'
+      end
+    end
+  end
+
+  let(:klass2) do
+    ClassBuilder.build do
+      def exec2
+        values << 'exec2'
+      end
+    end
+  end
+
+  let(:instance1) { klass1.new }
+  let(:instance2) { klass2.new }
+
+  let(:aspect_klass) do
+    ClassBuilder.inherit(Aspector::Base) do
+      attr_accessor :call_count
+
+      def initialize
+        @call_count = 0
+      end
+
+      before interception_arg: true do |interception|
+        interception.aspect.call_count += 1
+      end
+    end
+  end
+
+  let(:aspect) { aspect_klass.new }
+
+  context 'binding single aspect to multiple different targets' do
+    before do
+      aspect.apply klass1, method: :exec1
+      aspect.apply klass2, methods: %w( exec2 )
+    end
+
+    it 'should work' do
+      instance1.exec1
+      instance2.exec2
+
+      expect(aspect.call_count).to eq 2
+      expect(instance1.values).to eq %w( exec1 )
+      expect(instance2.values).to eq %w( exec2 )
+    end
+  end
+end

data/spec/functionals/aspect_interception_options_accessing_spec.rb

@@ -0,0 +1,112 @@
+require 'spec_helper'
+
+RSpec.describe 'Aspector options access' do
+  subject { klass.new }
+  let(:interception_options) { { rand => rand } }
+
+  context 'accessing interception options' do
+    let(:klass) do
+      ClassBuilder.build do
+        attr_accessor :interception_options
+      end
+    end
+
+    before do
+      aspect.apply klass, interception_options.merge(method: :exec)
+    end
+
+    context 'before aspect' do
+      let(:aspect) do
+        ClassBuilder.inherit(Aspector::Base) do
+          default aspect_field: 60
+
+          before interception_arg: true do |interception|
+            self.interception_options = interception.options
+          end
+        end
+      end
+
+      it 'should be able to reach interception options that were merged with aspect options' do
+        subject.exec
+        expected = interception_options.merge(method: :exec).merge(aspect_field: 60)
+        expect(subject.interception_options).to eq expected
+      end
+
+      it 'still should exec original method' do
+        subject.exec
+        expect(subject.values).to eq %w( exec-result )
+      end
+    end
+
+    context 'before_filter aspect' do
+      let(:aspect) do
+        ClassBuilder.inherit(Aspector::Base) do
+          default aspect_field: 60
+
+          before_filter interception_arg: true do |interception|
+            self.interception_options = interception.options
+          end
+        end
+      end
+
+      it 'should be able to reach interception options that were merged with aspect options' do
+        subject.exec
+        expected = interception_options.merge(method: :exec).merge(aspect_field: 60)
+        expect(subject.interception_options).to eq expected
+      end
+
+      it 'still should exec original method' do
+        subject.exec
+        expect(subject.values).to eq %w( exec-result )
+      end
+    end
+
+    context 'around aspect' do
+      let(:aspect) do
+        ClassBuilder.inherit(Aspector::Base) do
+          default aspect_field: 60
+
+          around interception_arg: true do |interception, proxy, &block|
+            self.interception_options = interception.options
+            proxy.call(&block)
+          end
+        end
+      end
+
+      it 'should be able to reach interception options that were merged with aspect options' do
+        subject.exec
+        expected = interception_options.merge(method: :exec).merge(aspect_field: 60)
+        expect(subject.interception_options).to eq expected
+      end
+
+      it 'still should exec original method' do
+        subject.exec
+        expect(subject.values).to eq %w( exec-result )
+      end
+    end
+
+    context 'after aspect' do
+      let(:aspect) do
+        ClassBuilder.inherit(Aspector::Base) do
+          default aspect_field: 60
+
+          after interception_arg: true do |interception, result|
+            self.interception_options = interception.options
+            result
+          end
+        end
+      end
+
+      it 'should be able to reach interception options that were merged with aspect options' do
+        subject.exec
+        expected = interception_options.merge(method: :exec).merge(aspect_field: 60)
+        expect(subject.interception_options).to eq expected
+      end
+
+      it 'still should exec original method' do
+        subject.exec
+        expect(subject.values).to eq %w( exec-result )
+      end
+    end
+  end
+end

data/spec/functionals/aspect_on_a_class_spec.rb

@@ -0,0 +1,159 @@
+require 'spec_helper'
+
+RSpec.describe 'Aspector for a class' do
+  context 'public class methods' do
+    subject do
+      ClassBuilder.build do
+        class << self
+          def values
+            @values ||= []
+          end
+
+          def exec
+            values << 'class-exec-result'
+          end
+        end
+      end
+    end
+
+    context 'before aspect' do
+      before do
+        aspector(subject, class_methods: true) do
+          before :exec do
+            values << 'class-exec-before'
+          end
+        end
+      end
+
+      it 'should work' do
+        subject.exec
+        expect(subject.values).to eq %w( class-exec-before class-exec-result )
+      end
+    end
+
+    context 'around aspect' do
+      before do
+        aspector(subject, class_methods: true) do
+          around :exec do |proxy, &block|
+            values << 'class-exec-around-before'
+            result = proxy.call(&block)
+            values << 'class-exec-around-after'
+            result
+          end
+        end
+      end
+
+      it 'should work' do
+        expected = %w( class-exec-around-before class-exec-result class-exec-around-after )
+        subject.exec
+        expect(subject.values).to eq expected
+      end
+    end
+
+    context 'after aspect' do
+      before do
+        aspector(subject, class_methods: true) do
+          after :exec do |result|
+            values << 'class-exec-after'
+            result
+          end
+        end
+      end
+
+      it 'should work' do
+        subject.exec
+        expect(subject.values).to eq %w( class-exec-result class-exec-after )
+      end
+    end
+  end
+
+  context 'private class methods' do
+    subject do
+      ClassBuilder.build do
+        class << self
+          def values
+            @values ||= []
+          end
+
+          private
+
+          def exec
+            values << 'class-exec-result'
+          end
+        end
+      end
+    end
+
+    context 'before aspect' do
+      before do
+        aspector(subject, class_methods: true) do
+          before :exec do
+            values << 'class-exec-before(public_methods_only)'
+          end
+        end
+
+        aspector(subject, class_methods: true, private_methods: true) do
+          before :exec do
+            values << 'class-exec-before'
+          end
+        end
+      end
+
+      it 'should work' do
+        subject.send(:exec)
+        expect(subject.values).to eq %w( class-exec-before class-exec-result )
+      end
+    end
+
+    context 'around aspect' do
+      before do
+        aspector(subject, class_methods: true) do
+          around :exec do |proxy, &block|
+            values << 'class-exec-around-before(public_methods_only)'
+            result = proxy.call(&block)
+            values << 'class-exec-around-after(public_methods_only)'
+            result
+          end
+        end
+
+        aspector(subject, class_methods: true, private_methods: true) do
+          around :exec do |proxy, &block|
+            values << 'class-exec-around-before'
+            result = proxy.call(&block)
+            values << 'class-exec-around-after'
+            result
+          end
+        end
+      end
+
+      it 'should work' do
+        expected = %w( class-exec-around-before class-exec-result class-exec-around-after )
+        subject.send(:exec)
+        expect(subject.values).to eq expected
+      end
+    end
+
+    context 'after aspect' do
+      before do
+        aspector(subject, class_methods: true) do
+          after :exec do |result|
+            values << 'class-exec-after(public_methods_only)'
+            result
+          end
+        end
+
+        aspector(subject, class_methods: true, private_methods: true) do
+          after :exec do |result|
+            values << 'class-exec-after'
+            result
+          end
+        end
+      end
+
+      it 'should work' do
+        subject.send(:exec)
+        expect(subject.values).to eq %w( class-exec-result class-exec-after )
+      end
+    end
+  end
+end