anchor 0.0.2 → 0.0.3

data/README.rdoc

@@ -5,7 +5,7 @@ Alternative for AOP libaries providing simple syntax and containing less than 10
 Containing only:
 * before
 * after
-* around
+* around (Not implemented yet)
 
 
 == Installation
@@ -16,61 +16,58 @@ Add to your Gemfile:
 And run:
   bundle install
 
+Or run:
+  gem install anchor
 
 
 == Naming recommendations
 
 You can name things as you want, but it is recommended to it so:
 
-=== Example A
+=== Example: Using *hooks* for *models* in Rails app (Not implemented yet)
 
 Create app/hooks/model_name.rb 
-  hook to: ModelName do
+  anchor ModelName do
 
-    before :save do |opts|
-      puts opts[:method_name]
-      puts opts[:arguments]
-      puts opts[:proc]
-
-    end
-
-    after :save do |opts|
-      puts opts[:method_name]
-      puts opts[:arguments]
-      puts opts[:proc]
-      puts opts[:return_value]
-
-    end
-
-    around :save do |opts|
-      puts opts[:method_name]
-      puts opts[:arguments]
-      puts opts[:proc]
-
-      # TODO ...
+    before :save do
+      puts "Before save #{self.inspect}"
     end
 
   end
 
 
-=== Example B
+=== Example: Using *hooks* for *conserns* in Rails app (Not implemented yet)
 
 Create app/hooks/model_name/what_for_hook_is_itended.rb
     ...
 
 
-=== Example C
+=== Example: Using *hooks* in *models*
 
 You can also do in app/models/your_model.rb
 
   class YourModel
-    extend Anchor::Hooked
+    include Anchor::Hooks
 
     before :save do
-      puts "Saving #{self.inspect}"
+      puts "Before save #{self.inspect}"
     end
 
   end
 
 
 
+== Usage examples
+
+=== You can find some examples from:
+
+* https://github.com/tione/anchor/blob/master/test/test.rb
+
+
+=== Method regexp
+
+  anchor Yourmodel do
+    before self.instance_methods.grep(/$methods/) do
+      puts 
+    end
+  end

data/lib/anchor.rb

@@ -1,2 +1,3 @@
-require 'anchor/hooked'
 require 'kernel'
+require 'anchor/hooks'
+

data/lib/anchor/hooks.rb

@@ -0,0 +1,72 @@
+# = Anchor
+module Anchor
+  def self.hook(*objs, &block)
+    objs.each do |obj|
+      #puts "Trying to hook: #{obj} #{block.inspect}"
+      Hooks.included(obj)
+      obj.instance_eval &block
+    end
+  end
+  # == Hooks
+  # Something similar to AOP, but much more simplified, providing: before, after, around
+  module Hooks     
+    # DSL
+    module DSL
+      module Keywords
+        def singleton *methods;      [{singleton: methods.shift}, *methods]; end
+        def instance *methods;       [{instance: methods.shift}, *methods];  end
+      end
+      module HookTypes
+        def before(*methods, &block);   add_hook(:before, *methods, &block); end
+        def after(*methods, &block);    add_hook(:after, *methods, &block);  end  
+        def around(*methods, &block);   add_hook(:around, *methods, &block); end
+      end
+    end
+    # Hooked
+    module Hooked
+      def add_hook_for_methods(type, *methods, &block)
+        methods.flatten.each {|method| add_hook_for_method(type, method, &block)}      
+      end
+      alias :add_hook :add_hook_for_methods
+      
+      def add_hook_for_method(type, method, &block)
+        level, name = case method; when Hash; method.shift; when Symbol; [:instance, method]; end        
+        # set hooks on metaclass instance, not self, if method has to be class method or self is a Object
+        in_scope = :metaclass if level == :singleton or not self.is_a?(Class) 
+        return Anchor.hook(class << self; self; end) do
+          self.send(type, name, &block)
+        end if in_scope == :metaclass        
+        # replace orginal method with hooked method          
+        instance_exec do
+          hooks = @hooks ||= {}
+          @hooks[name] ||= {}
+          @hooks[name][type] ||= []
+          @hooks[name][type] << block
+          orginal_methods = @orginal_methods ||= {}
+          
+          unless @orginal_methods[name]
+            @orginal_methods[name] = self.instance_method(name)
+            define_method name do 
+              hooks[name][:before].each {|proc| proc.call} if hooks[name][:before]
+              retval = orginal_methods[name].bind(self).call
+              hooks[name][:after].each {|proc| proc.call} if hooks[name][:after]
+              retval
+            end
+          end
+          
+        end
+      end      
+    end
+    # Add Anchor::Hooked methods to be static
+    def self.included(base) # :nodoc:
+      base.instance_eval {  extend Anchor::Hooks::ClassMethods }
+    end
+    # ClassMethods
+    module ClassMethods
+      include Anchor::Hooks::DSL::Keywords
+      include Anchor::Hooks::DSL::HookTypes
+      include Anchor::Hooks::Hooked
+    end
+  end
+
+end

data/lib/kernel.rb

@@ -1,9 +1,5 @@
 module Kernel
-  def hook(opts, &block)
-    hook_to = opts[:to]
-    hook_to.module_eval do
-      extend Anchor::Hooked
-      module_eval &block
-    end
+  def anchor(*objs, &block)
+    Anchor.hook(*objs, &block)
   end
 end

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 0
-  - 2
-  version: 0.0.2
+  - 3
+  version: 0.0.3
 platform: ruby
 authors: 
 - "Margus P\xC3\xA4rt"
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-01-01 00:00:00 +02:00
+date: 2012-01-03 00:00:00 +02:00
 default_executable: 
 dependencies: []
 
@@ -28,7 +28,7 @@ extra_rdoc_files: []
 
 files: 
 - README.rdoc
-- lib/anchor/hooked.rb
+- lib/anchor/hooks.rb
 - lib/kernel.rb
 - lib/anchor.rb
 has_rdoc: true

data/lib/anchor/hooked.rb

@@ -1,74 +0,0 @@
-
-module Anchor
-  # Something similar to AOP, but much more simplified, providing:
-  # * before
-  # * after
-  # * around
-  module Hooked
-    # Information about hooks is stored in @hooks
-    attr_reader :hooks
-    # Orginal methods are not aliased but stored in @orginal_methods as UnboundMethod
-    attr_reader :orginal_methods
-    
-    def before(*methods, &block)
-      create_hook(:before, *methods, &block)
-    end
-  
-    def after(*methods, &block)
-      create_hook(:after, *methods, &block)    
-    end
-  
-    def around(*methods, &block)
-      create_hook(:around, *methods, &block)
-    end
-    
-    def create_hook(type, *methods, &block)
-      @hooks ||= {}
-      @orginal_methods ||= {}
-      
-      methods.each do |method|
-        method_scope  = :instance
-        method_name   = case method; when Hash; method_scope, name = method.flatten; name; when Symbol; method; end
-        
-        # if hook on static, call new hook on self metaclass
-        return hook({to: class << self; self; end}, &block) if method_scope == :static
-                
-        # register hook
-        @hooks[method_name] ||= {}  
-        @hooks[method_name][type] ||= []
-        @hooks[method_name][type] << block        
-        
-        # store and replace orginal method
-        unless @orginal_methods[method_name]
-          # store orginal
-          @orginal_methods[method_name] = self.instance_method(method_name)
-          
-          # replace orginal to call hooks and orginal          
-          define_method method_name do   
-            hooks             = self.class.methods.include?(:hooks) ? self.class.hooks : class << self; self.hooks; end            
-            orginal_methods   = self.class.methods.include?(:orginal_methods) ? self.class.orginal_methods : class << self; self.orginal_methods; end    
-            # Hooks. Before.
-            before_hooks  = hooks[method_name][:before]
-            before_hooks.each do |proc|
-              proc.call
-            end if before_hooks         
-            # bind method to self and call
-            retval        = orginal_methods[method_name].bind(self).call              
-            # Hooks. After.              
-            after_hooks   = hooks[method_name][:after]
-            after_hooks.each do |proc|
-              proc.call
-            end if after_hooks
-            # return value returned by orginal method
-            retval
-          end
-        end
-
-      
-      end  
-    end 
-    protected :create_hook
-    
-  end
-
-end