aspekt 0.0.1 → 0.0.2

data/Gemfile

@@ -1,3 +1,11 @@
 source 'http://rubygems.org'
 
 gem 'is_same'
+
+group :development, :test do
+  gem 'rspec'
+  gem 'rspec-core'
+  gem 'rdoc'  				# yard uses rdoc
+  gem 'yard'
+  gem 'yard-rspec'
+end

data/lib/aspekt/advice.rb

@@ -0,0 +1,57 @@
+module Aspekt
+
+
+
+  class Advice < Aspekt::Object
+
+    # Creates new Advice Object
+    #
+    # == Example usage
+    #
+    #   advice = Aspekt::Advice.new type: :before, pointcut: pointcut do |joinpoint|
+    #     puts "before #{joinpoint}"
+    #   end
+    #
+    #   advice = Aspekt::Advice.new type: :around, pointcuts: [pointcut1, pointcut2] do |joinpoint|
+    #     puts "around :start for #{joinpoint}"
+    #     return_value = joinpoint.proceed
+    #     puts "around :end for #{joinpoint}"
+    #   end
+    #
+    # @param {:type => :before|:after|:around, :pointcut|:pointcuts => Pointcut.new(...)|[Pointcut.new(...)]}
+
+    def initialize opts, &block
+      raise ArgumentError, "type has to be Symbol: before, after or around, but got '#{opts[:type]}'" unless [:before, :after, :around].include?(opts[:type])
+      raise ArgumentError, "has to define at least one Pointcut with :pointcut or :pointcuts" unless opts.has_key?(:pointcut) or opts.has_key?(:pointcuts)
+
+      # get the module in which advice was created
+      begin
+        opts[:module] = caller.including_same(/<module:/).collect {|l| /<module:(.*)>/.match(l)[1] }.reverse.inject(Object) {|a, b| a.const_get(b) }
+      rescue
+      end
+
+      # add block info to opts
+      opts[:proc] = block
+
+      # register opts values
+      super
+
+      # weave into the code
+      weave &block
+    end
+
+
+    # Weaves advice into the code.
+    #
+    # @see Aspekt::Weaver
+
+    def weave &block
+      Aspekt::Weaver.send(self[:type], self.values_at(:pointcut, :pointcuts).flatten.compact, &block)
+    end
+    private :weave
+
+  end
+
+
+
+end

data/lib/aspekt/helpers/shorthand_methods.rb

@@ -0,0 +1,80 @@
+module Aspekt
+  module Helpers
+    module ShorthandMethods
+
+      # Shorthand for before advice.
+      #
+      # === Examples
+      #
+      #   before type: Test, methods: /to_/ do
+      #     puts "Before called on a object #{self}"
+      #   end
+      #   
+      #   before(
+      #           {type: Class1, method: :method1},
+      #           {types: [Class2, Class3], methods: [/cotaining/, :method3]},
+      #           {instances: [Class3, Class4, some_object], method: :lal}
+      #          ) do |joinpoint|    
+      #     puts "Before #{joinpoint[:method]} on #{self}. Other information of joinpoint: #{joinpoint}."
+      #   end
+      #                                                                     
+      #   class TestMe
+      #     before methods: [:a, /b/] do |joinpoint|   # note how type or instance is not specified, it is automatically resolved to self (what is TestMe in class body)
+      #       puts "Before #{joinpoint}!"
+      #     end
+      #   end
+
+      def before *pointcuts, &block
+        Aspekt::Advice.new type: :before, pointcuts: pointcuts, &block
+      end
+
+
+
+      # Shorthand for after advice.
+      #
+      # === Examples
+      #
+      #   after type: Test, methods: /to_/ do
+      #     puts "Before called on a object #{self}"
+      #   end
+      #
+      #   class TestMe
+      #     after methods: [:a, /b/] do |joinpoint|   # note how type or instance is not specified, it is automatically resolved to self (what is TestMe in class body)
+      #       puts "After #{joinpoint}!"
+      #     end
+      #   end
+
+      def after *pointcuts, &block
+        Aspekt::Advice.new type: :after, pointcuts: pointcuts, &block
+      end
+
+
+
+      # Shorthand for around advice.
+      #
+      # === Example
+      #
+      #   around type: Test, methods: /to_/ do |joinpoint|
+      #     puts "Before called on a object #{self} and method #{joinpoint[:method]}"
+      #     result = joinpoint.proceed
+      #     puts "After called on a object #{self} and method #{joinpoint[:method]}"
+      #     result
+      #   end
+      #
+      #   class TestMe
+      #     around methods: [:a, /b/] do |joinpoint|   # note how type or instance is not specified, it is automatically resolved to self (what is TestMe in class body)
+      #       puts "Before around #{joinpoint}!"
+      #       result = joinpoint.proceed
+      #       puts "After around #{joinpoint}!"
+      #       result 
+      #     end
+      #   end
+
+      def around *pointcuts, &block
+        Aspekt::Advice.new type: :around, pointcuts: pointcuts, &block
+      end
+
+
+    end
+  end
+end

data/lib/aspekt/joinpoint.rb

@@ -0,0 +1,18 @@
+module Aspekt
+
+
+
+  class Joinpoint < Aspekt::Object
+
+
+    # Execute the orginal method.
+
+    def proceed
+      self[:bound_method].(*self[:args], &self[:block])
+    end
+
+  end
+
+
+
+end

data/lib/aspekt/object.rb

@@ -0,0 +1,44 @@
+module Aspekt
+
+
+
+  # All Aspekt's objects are extended from Aspekt::Object.
+  #
+  # It extends Hash.
+  class Object < Hash
+
+
+    # Creates a new Aspekt::Object with base class Hash and registres self in class :@all.
+    #
+    # === Example
+    # 
+    #   class MyClass < Aspekt::Object; end
+    #   obj = MyClass.new a: 'b', c: 'd'
+    #   obj               # {a: 'b', c: 'd'}
+
+    def initialize opts = {}
+      raise ArgumentError, "should be Hash" unless opts.is_a?(Hash)
+
+      self.merge! opts
+      self.class.all << self
+    end
+
+
+    # Will be probleby deparated and implemented as aspect
+    # 
+    # === Example
+    #
+    #   class MyClass < Aspekt::Object; end
+    #   object1 = MyClass.new
+    #   object2 = MyClass.new
+    #   MyClass.all    # will contain object1 and object2
+    
+    def self.all
+      @all ||= []
+    end
+    
+  end
+
+
+  
+end

data/lib/aspekt/pointcut.rb

@@ -0,0 +1,157 @@
+module Aspekt
+
+
+    # Examples of usage can also be found in https://github.com/tione/aspekt/blob/development/spec/aspekt/pointcut_spec.rb
+
+    class Pointcut < Aspekt::Object
+
+
+    # Constructor takes for arguments Hash with keys class(es) or object(s) and method(s), or Array of Hash-es. 
+    #
+    # === Example
+    # ==== Pointcut for object method
+    #
+    #   pointcut = Aspekt::Pointcut.new(type: :String, method: :to_s)
+    #   pointcut = Aspekt::Pointcut.new(type: /String/, method: /to_s/)
+    #   pointcut = Aspekt::Pointcut.new(type: String, method: 'to_s')
+    #
+    #
+    # ==== Pointcut for class method (singleton method)
+    #
+    #   pointcut = Aspekt::Pointcut.new(instance: String, method: :new)
+    #   pointcut = Aspekt::Pointcut.new(type: (class String; class<<self; self; end; end, method: :new)
+    #   pointcut = Aspekt::Pointcut.new(instance: some_object, method: /some_singleton_method/)
+    #
+    #
+    # ==== Pointcut with more than a one matcher
+    #
+    #   pointcut = Aspekt::Pointcut.new(
+    #                                   {type: String, method: :capitalize},
+    #                                   {types: [String, Array], methods: [/a/, /o/]},
+    #                                   {instances: [String, /Arr/], method: /new|try/}
+    #                                   )
+    #
+    # ==== Reasoning behind :type and :instance
+    #
+    # - using :type or :types (see: http://ruby-doc.org/core-1.9.3/BasicObject.html#method-i-instance_exec)
+    # - using :instance or :instances (see: http://ruby-doc.org/core-1.9.3/Module.html#method-i-module_exec)
+    #
+    # @param Array<{:type => Class|::Object|String|Symbol|Regexp, :instance => ::Object}>
+
+    def initialize *matchers
+      raise ArgumentError, "must have matchers" if matchers.length == 0 
+
+      matchers.each { |matcher| add_matcher matcher }
+    end
+
+
+    # Add matcher for a pointcut.
+    #
+    # Restructures matchers for faster searches.
+    # Structure will be in self[:matchers] {instances: {Object1: [:method1, :method2], Object2: [:method3, :method4]}, types: {Class1: [:method5], ...}}
+    #
+    # @private
+    # @param {:method => Symbol, :methods => Array<Symbol>, :instance|:type => Object, :instances|:types => Array<Object> }
+
+    def add_matcher matcher 
+      raise ArgumentError, "matcher must be a Hash" unless matcher.is_a?(Hash)
+
+      # extract values
+      matcher_methods   = matcher.values_at(:method, :methods).flatten.compact
+      matcher_instances = matcher.values_at(:instance, :instances).flatten.compact
+      matcher_types     = matcher.values_at(:type, :types).flatten.compact
+
+      raise ArgumentError, "must include :method|:methods" if matcher_methods.length == 0
+      raise ArgumentError, "must include :type(s)|:instance(s)" if matcher_instances.length == 0 and matcher_types.length == 0
+      
+      # add values to structure
+      matcher_instances.each do |matcher_instance|
+        self[:instances] ||= {}
+        self[:instances][matcher_instance] ||= []
+        self[:instances][matcher_instance].concat matcher_methods
+      end
+      matcher_types.each do |matcher_type|
+        self[:types] ||= {}
+        self[:types][matcher_type] ||= []
+        self[:types][matcher_type].concat matcher_methods
+      end
+      
+      return true 
+    end
+    private :add_matcher
+
+
+    # Argument Hash with keys :class or :object and :method for checking if Pointcut is matching with a object or a class.
+    #
+    # === Example
+    #
+    #   pointcut = Aspekt::Pointcut.new(class: :SomeClass, method: :some_method).has_matchers_for?(class: SomeClass, method: :some_method)
+    #   pointcut = Aspekt::Pointcut.new(object: :SomeClass, method: :some_method).has_matchers_for?(object: SomeClass, method: :some_method)
+    #
+    # @param Array<{:type => Class|::Object|Symbol|Regexp, :instance => ::Object, :method => Symbol}>
+
+    def has_matchers_for? opts
+      raise ArgumentError, "has to include keys 'instance' or 'type', may include 'method'." unless opts[:instance] or opts[:type]
+
+      # matcher_branch - from where to search matcher, thing - class or object
+      matcher_branch, thing = case 
+      when opts[:instance]; [self[:instances], opts[:instance]];
+      when opts[:type];     [self[:types], opts[:type]];
+      end
+        
+      matchers_for_thing = matcher_branch.keys.including_same thing
+      
+      unless matchers_for_thing.length == 0
+        return true unless opts[:method]  # we have no method matching and object is matching
+        matcher_objects_methods = matcher_branch.values_at(*matchers_for_thing).flatten
+        return true if matcher_objects_methods.include_same?(opts[:method]) # one of the matching object has matching method
+      end
+
+      return false # opts[:object] existed but no matcher was found
+    end
+
+
+    # Finds currently existing all Objects for this Pointcut. Returns Object and its method matchers.
+    #
+    # === Example
+    #
+    #   pointcut = Pointcut.new(types: [/Strin/, /^Hash$/, :ThisClassDoesNotExist)], instance: Array, methods: [/to/, :send])
+    #   pointcut_matching_types     = pointcut.matching[:types]       # will be: {String: [/to/, :send], Hash: [/to/, :send]}
+    #   pointcut_matching_instances = pointcut.matching[:instances]   # will be: {Array: [/to/, :send]}
+    #
+    #   # if now ThisClassDoesNotExist will be defined and #matching is called again, then it will also contain it.
+    
+    def matching
+      matching = {}
+
+      defined_classes = nil # this will be created for Regexp object matcher, if needed
+
+      self.each do |type, object_matchers|
+        matching[type] = {}
+
+        object_matchers.each do |object_matcher, methods|
+          case object_matcher
+          when Symbol
+            begin
+              matching_class = object_matcher.to_s.split(/::/).inject(Object) {|a, b| a.const_get(b) } # throws NameError if does not exist
+              matching[type][matching_class] = methods
+            rescue NameError
+            end
+          when Regexp
+            defined_classes ||= ObjectSpace.each_object(Class).to_a # do it when need it
+            defined_classes.select {|defined_class| matching[type][defined_class] = methods if object_matcher.match(defined_class.name) }
+          else
+            matching[type][object_matcher] = methods
+          end
+        end
+
+      end
+
+      return matching
+    end
+
+
+
+  end
+
+end

data/lib/aspekt/weaver.rb

@@ -0,0 +1,192 @@
+module Aspekt
+
+
+  # Responsible for weaving code into methods.
+  #
+  # == You can use Weaver so:
+  #
+  # === ... in method call to Aspekt::Weaver
+  #
+  #   Aspekt::Weaver.before class: ExistingClass, method: :existing_method do |joinpoint|
+  #     puts "before context: '#{joinpoint[:context]}' and method '#{joinpoint[:method]}'"  
+  #   end
+  #
+  #
+  # === ... in where you want to (for example class definition body).
+  #  
+  #    include Aspekt::Weaver
+  #    
+  #    # for object derived from this class:
+  #    before method: :my_method |joinpoint|                  # if :type(s)|:method(s) is missing, then automatically type will be self.
+  #      puts "before #{joinpoint[:method]}"
+  #    end
+  #    before type: self, method: :my_method do |joinpoint|   # remember that self in class body will be Class
+  #      puts "before #{joinpoint[:method]}"
+  #    end
+  #    
+  #    # singleton
+  #    before instance: self, method: :my_method do |joinpoint|   # remember that self in class body will be Class and its treated as instance now
+  #      puts "before #{joinpoint[:method]}"
+  #    end
+  #    before type: (class<<self; self; end), method: :my_method do |joinpoint|   # accessing self metaclass
+  #      puts "before #{joinpoint[:method]}"
+  #    end
+  # 
+  #
+  # === More complicated examples:
+  #  
+  #    Aspekt::Weaver.before instances: [Object1, :ClassHereForSingletonMethods], types: [Class1, :Class2], methods: [:method1, 'method2', /d3/] do |joinpoint|
+  #      puts "Called in the context of a object: #{joinpoint[:context]} and method is: #{joinpoint[:method]}"
+  #    end
+  #
+  #    Aspekt::Weaver.before types: //, methods: /secure/ do |joinpoint|
+  #      throw SecurityException, "not secure enough" unless authenticated_user.is_secured?
+  #    end
+  #
+  #
+  #   
+  # More examples can be found in Rspec tests: https://github.com/tione/aspekt/blob/development/spec/aspekt/weaver_spec.rb
+  #
+  # === Weaver does not support Regexp in its object and method matching
+  #
+  # Therefore its recommended to use Aspects, Advices and Pointcuts that do support Regexp.
+
+  module Weaver
+    extend self
+
+
+    # When included to a Class or Object, there will be Weaver methods available.
+
+    def self.included base #:nodoc:
+      base.extend self
+    end
+
+
+    # Weaves Proc to method.
+    #
+    # If argument matcher is a Hash not a Aspekt::Pointcut, it will be converted to it.
+    #
+    # @param Array<Hash|Aspekt::Pointcut> for hash see Aspekt::Pointcut.new
+
+    def weave *pointcuts_or_matchers
+
+      # if not pointcut, convert to it. (it might be a regexp matcher?)
+      pointcuts = pointcuts_or_matchers.flatten.collect do |pom|
+        case pom
+        when Aspekt::Pointcut
+          pom
+        when Hash
+          # Add DSL support for if include Aspekt::Weaver was called in a class.
+          pom[:type] = self if !(pom[:type] or pom[:types] or pom[:instance] or pom[:instances]) and self != Aspekt::Weaver 
+          Aspekt::Pointcut.new pom
+        else
+          raise ArgumentError, "should be Hash or Aspekt::Pointcut but was #{pom.class} (#{pom})"
+        end
+      end
+
+      # iterate over pointcuts
+      pointcuts.each do |pointcut| 
+        # objects to be weaved into
+        matching = pointcut.matching 
+        objects = matching[:types] || {}
+        matching[:instances].each do |instance, methods| 
+          singleton = class<<instance; self; end
+          objects[singleton] ||= []
+          objects[singleton].concat methods
+        end if matching[:instances]
+
+        # iterate through objects (classes and singleton classes)
+        objects.each do |object, method_matchers|
+          object.module_exec do
+            weave_methods = object.instance_methods.select {|meth| method_matchers.include_same? meth }
+            
+            weave_methods.each do |weave_method|
+              m = instance_method(weave_method)
+
+              # replace orginal method with orginal method + what we got as block to yield
+              define_method(weave_method) do |*args, &block|
+                bm = m.bind self
+                joinpoint = Aspekt::Joinpoint.new args: args, block: block, context: self, method: weave_method, bound_method: bm
+                yield(joinpoint)
+              end 
+            end
+          end
+        end
+      end
+
+    end
+
+
+    # Weaves Proc before the method.
+    #
+    # == Example usage for object
+    #
+    #   string = "trolololo"  
+    #
+    #   Aspekt::Weaver.before object: string, method: :to_s do |joinpoint|
+    #     puts "Before self: #{self} joinpoint: #{joinpoint}"
+    #   end
+    #
+    #   new_string = string.to_s  # output: Before trolololo at {:args=>[], :block=>nil, :context=>"trolololo", :method=>:to_s, :bound_method=>#<Method: String(String)#to_s>}
+    #   puts new_string           # output: "trolololo"
+    #
+    #
+    # == Example usage for all objects that derive from certain classes
+    #
+    #   Aspekt::Weaver.before classes: [Array, String], methods: [:initialize, :to_s] do
+    #     puts "#{self} is doing something important #{joinpoint}"
+    #   end
+
+    def before opts, &block
+      self.weave opts do |joinpoint|
+        joinpoint[:context].instance_exec joinpoint, &block                           # call block with argument joinpoint
+        joinpoint.proceed                                                             # call orginal method
+      end
+    end
+
+
+    # Weaves Proc after the method.
+    # @see Aspekt::Weaver.before
+
+    def after opts, &block
+      self.weave opts do |joinpoint|
+        retval = joinpoint.proceed                                                    # call orginal method
+        joinpoint.merge! retval: retval                                               # add orginal method retval 
+        joinpoint[:context].instance_exec joinpoint, &block                           # call block with argument joinpoint
+        retval
+      end
+    end
+
+
+    # Wheaves Proc for around.
+    #
+    # == Example usage
+    #
+    #   hash = {key: :value}
+    #   puts "Hash ID is: #{hash.object_id}"
+    #  
+    #   Aspekt::Weaver.around object: hash, method: :has_key? do |joinpoint|
+    #     puts "Enter: #{joinpoint}"
+    #     puts "My self ID is: through self #{self.object_id} and through joinpoint[:context] #{joinpoint[:context].object_id}"
+    #     result = joinpoint.proceed
+    #     puts "Exit with result #{result}: #{joinpoint}"
+    #   end
+    #
+    #   # Calling `hash.has_key?(:key)` outputs:   
+    #   # Hash ID is: 15441680
+    #   # Enter: {:args=>[:key], :block=>nil, :context=>{:key=>:value}, :method=>:has_key?, :bound_method=>#<Method: Hash(Hash)#has_key?>}
+    #   # My self ID is: through self 15441680 and through joinpoint[:context] 15441680
+    #   # Exit with result true: {:args=>[:key], :block=>nil, :context=>{:key=>:value}, :method=>:has_key?, :bound_method=>#<Method: Hash(Hash)#has_key?>}
+
+    def around opts, &block
+      self.weave opts do |joinpoint|
+        joinpoint[:context].instance_exec joinpoint, &block                           # call block with argument joinpoint
+        # calling joinpoint.proceed should be done in the block
+      end
+    end
+
+  end
+
+
+
+end

data/lib/aspekt.rb

@@ -1,137 +1,41 @@
+#$: << '.' unless $:.include?('.')
+
 require 'is_same'                     # https://github.com/tione/is_same
 
 
-# Supports only already existing objects (and classes) and methods Weaving.
-# Aspects defined in folder ./aspects will add runtime loading.
+
+# *Aspekt* consists of multiple classes, but for the libary user should be important only following methods:
 #
-# @see Aspekt::Pointcut
-# @see Aspekt::Advice
+# * {#before  before}
+# * {#after   after}
+# * {#around  around}
+
 module Aspekt
+end
 
 
 
-  # All Aspekt's objects are extended from Aspekt::Object.
-  class Object < Hash
-
-    # Creates a new Aspekt::Object with base class Hash and registres self in class :@all.
-    def initialize opts
-      self.merge! opts
-      self.class.all << self
-    end
-
-    # Returns all Objects created.
-    def self.all
-      @all ||= []
-    end
-
-  end
-
-
-  class Pointcut < Aspekt::Object
-
-    # === Example usage
-    #   class SomeClass
-    #
-    #     def self.some_method
-    #       return "some_value_from_singleton"
-    #     end
-    #
-    #     def some_method
-    #       return "some_value"
-    #     end
-    #
-    #     def other_method
-    #       return "other_value"
-    #     end
-    #
-    #   end
-    #
-    #   some_object = SomeClass.new
-    #
-    # ==== Pointcuts for instance with types
-    #   pointcut = Aspekt::Pointcut.new( class: :SomeClass, method: :some_method )
-    #   pointcut = Aspekt::Pointcut.new( class: SomeClass, method: /some/ )
-    #   pointcut = Aspekt::Pointcut.new( class: /Some/, method: /some/ )
-    #
-    # ==== Pointcut for class method (singleton method)
-    #   pointcut = Aspekt::Pointcut.new( object: SomeClass, method: :some_method )
-    #   pointcut = Aspekt::Pointcut.new( object: /Some/, method: /some/)
-    #   pointcut = Aspekt::Pointcut.new( class: (class SomeClass; class<<self; self; end; end, method: :some_method )
-    #
-    # ==== Pointcut for only one object
-    #   pointcut = Aspekt::Pointcut.new( object: some_object, method: :some_method)
-    #
-    # === Arguments
-    # - object: object, method: :method
-    # - [{object: object, method: :method}, {object: object2, method: :method2
-    # - objects: [object, object2], methods: [:method, :method2]
-    # - class: :SomeClass, methods: [:method, :method2]
-    # - [{objects: [Hash, Array], method: new}, {class: Array, method: :push}, {classes: [Hash, Array, SomeClass], method: /_id/}]
-    #
-    # ==== Limitations
-    # Instances of Regexp, Symbol and Constant are used as finders not thought of as objects.
-    # TODO: Fix. Possibly add a new hash key value?
-
-    def initialize *matchers 
-      matchers = matchers.flatten.each do |matcher|
-        matcher[:classes] = [matcher.delete(:class)].flatten if matcher.has_key?(:class)
-        matcher[:objects] = [matcher.delete(:object)].flatten if matcher.has_key?(:object)
-        matcher[:methods] = [matcher.delete(:method)].flatten if matcher.has_key?(:method)
-      end
-      super matchers: matchers
-    end
-
-    # === Example usage
-    #   pointcut = Aspekt::Pointcut.new( class: :SomeClass, method: :some_method ).is_matching?( object: SomeClass.new )
-    #   pointcut = Aspekt::Pointcut.new( object: :SomeClass, method: :some_method ).is_matching?( object: SomeClass )
-    #
-    # === Arguments
-    # - object: object
-    # - object: object, method: :method
-    def is_matching? opts
-      raise ArgumentError, "has to include keys 'object', may include 'method'." unless opts[:object]
-
-      self[:matchers].each do |matcher|
-        # object matching
-        return true if
-        (matcher.has_key(:objects) and matcher[:objects].select{|object| object.is_same?(opts[:object])}.length > 0) or
-        (matcher.has_key(:classes) and matcher[:classes].select{|klass| klass.is_same?(opts[:object].class.name)}.length > 0)
-        # method matching
-        return true unless opts.has_key?(:methods) or
-        (matcher.has_key(:methods) and matcher[:methods].select{|klass| klass.is_same?(opts[:methods].class.name)}.length > 0)
-      end
-
-      return false
-    end
-
-   end
-
-
-
-  class Advice < Aspekt::Object
-
-    # == Example usage
-    #   advice = Aspekt::Advice.new ( type: :before, pointcut: pointcut ) do |joinpoint|
-    #     puts "before #{joinpoint}"
-    #   end
-    #
-    #   advice = Aspekt::Advice.new ( type: :around, pointcuts: [pointcut1, pointcut2]) do |joinpoint|
-    #     puts "around :start for #{joinpoint}"
-    #     return_value = joinpoint.proceed
-    #     puts "around :end for #{joinpoint}"
-    #   end
-    #
-    def initialize opts
-      opts[:pointcuts] = [opts.delete(:pointcut)].flatten if opts[:pointcut]
-      super opts
-      raise ArgumentError, "type has to be Symbol: before, after or around" unless [:before, :after, :around].include?(self[:type])
-      raise ArgumentError, "no pointcut defined" unless self[:pointcuts].length   
-    end
-
-  end
+# Core
 
+require 'aspekt/object'
+require 'aspekt/joinpoint'
+require 'aspekt/pointcut'
+require 'aspekt/advice'
+require 'aspekt/weaver'
 
 
-end
 
+# Shorthand methods
+
+require 'aspekt/helpers/shorthand_methods.rb'
 
+include Aspekt::Helpers::ShorthandMethods # introduces aspect(), advice() and pointcut()
+
+
+
+# Load aspects
+
+$LOAD_PATH.each do |folder|
+  aspects_folder = "#{folder}/aspects"
+  Dir.glob("#{aspects_folder}/**/*.rb") {|file| require file } if Dir.exists? aspects_folder
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: aspekt
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-02-13 00:00:00.000000000Z
+date: 2012-02-25 00:00:00.000000000Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: is_same
-  requirement: &22453880 !ruby/object:Gem::Requirement
+  requirement: &13075360 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,10 +21,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *22453880
+  version_requirements: *13075360
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &22453420 !ruby/object:Gem::Requirement
+  requirement: &13074900 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,10 +32,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *22453420
+  version_requirements: *13074900
 - !ruby/object:Gem::Dependency
-  name: rdoc
-  requirement: &22453000 !ruby/object:Gem::Requirement
+  name: rspec-core
+  requirement: &13074480 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -43,16 +43,43 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *22453000
+  version_requirements: *13074480
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: &13074060 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *13074060
+- !ruby/object:Gem::Dependency
+  name: yard-rdoc
+  requirement: &13073640 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *13073640
 description: Before, after and around method calls. Supports Regexp matching.
 email: margus@tione.eu
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- README.rdoc
 - Gemfile
 - lib/aspekt.rb
+- lib/aspekt/object.rb
+- lib/aspekt/helpers/shorthand_methods.rb
+- lib/aspekt/joinpoint.rb
+- lib/aspekt/pointcut.rb
+- lib/aspekt/weaver.rb
+- lib/aspekt/advice.rb
 homepage: https://github.com/tione/aspekt
 licenses: []
 post_install_message: 
@@ -76,5 +103,6 @@ rubyforge_project:
 rubygems_version: 1.8.15
 signing_key: 
 specification_version: 3
-summary: IN THE MAKING, NOT USABLE.
+summary: AOP libary with simple and capable before(), after() and around().
 test_files: []
+has_rdoc: 

data/README.rdoc

@@ -1,19 +0,0 @@
-= IN THE MAKING, NOT USABLE
-
-== Installation
-
-Add to your Gemfile:
-  gem 'aspekt'
-
-And run:
-  bundle install
-
-Or run:
-  gem install aspekt
-
-
-== Usage examples
-
-=== Including before, after and around methods support into Object or Class
-
-=== Creating aspects