rinterceptor 0.1.0

data/CHANGELOG

@@ -0,0 +1,3 @@
+Changes in version 0.1.0 (2009-03-9)
+-------------------------------------
+initial release

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2008 [name of plugin creator]
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,29 @@
+require 'rubygems'
+require 'rake/gempackagetask'
+PKG_NAME = "rinterceptor"
+PKG_VERSION = "0.1.0"
+PKG_FILE_NAME = "#{PKG_NAME}-#{PKG_VERSION}"
+PKG_FILES = FileList[
+  '[A-Z]*',
+  'lib/**/*'
+]
+spec = Gem::Specification.new do |s|
+  s.platform = Gem::Platform::RUBY
+  s.summary = "it is a inheritable, reusable AOP framework"
+  s.name = PKG_NAME
+  s.version = PKG_VERSION
+  s.require_path = 'lib'
+  s.homepage = %q{http://rinter.rubyforge.org/}
+  s.rubyforge_project = 'Rinterceptor'
+  s.has_rdoc = false
+  s.authors = ["Leon Li"]
+  s.email = "scorpio_leon@hotmail.com"
+  s.files = PKG_FILES
+  s.description = <<-EOF
+    it is a inheritable, reusable AOP framework with regex rule support, let your interceptor simple, flexible and with high expandability
+  EOF
+end
+Rake::GemPackageTask.new(spec) do |pkg|
+  pkg.need_zip = true
+  pkg.need_tar = true
+end

data/lib/example_rinterceptor.rb

@@ -0,0 +1,80 @@
+#!/usr/bin/env ruby
+require 'rinterceptor'
+module ExampleRinterceptor
+  def rinter_before(method, *args)
+    p "instance before -- method: #{method}, args: #{args} in ExampleRinterceptor"
+  end
+  def rinter_after(method, result, e, *args)
+    p "instance after -- method: #{method}, result: #{result}, e: #{e}, args: #{args} in ExampleRinterceptor"
+    result
+  end
+
+  module ClassMethods
+    def rinter_before(method, *args)
+      p "singleton before -- method: #{method}, args: #{args} in ExampleRinterceptor"
+    end
+    def rinter_after(method, result, e, *args)
+      p "singleton after -- method: #{method}, result: #{result}, e: #{e}, args: #{args} in ExampleRinterceptor"
+    end
+  end
+  include Rinterceptor
+end
+
+module SubExampleRinterceptor
+  def self.rinter_before_include_class(base)
+    p "before_include_class in SubExampleRinterceptor"
+    #set interceptor rules of instance methods, the variable can also be defined in class before include this module 
+    base.instance_variable_set(:@include_i_methods, {nil => [/^i2_/, /^i3_/], :handler_it => /^i1_/})
+  end
+  def self.rinter_after_include_class(base)
+    p "after_include_class in SubExampleRinterceptor"
+  end
+  def rinter_handler_it_around(invocation)
+    p "instance handler_it around begin -- method: #{invocation.method}, args: #{invocation.args} in SubExampleRinterceptor"
+    result = invocation.invoke("inter", "ddddd")
+    p "instance handler_it around end -- method: #{invocation.method}, args: #{invocation.args} in SubExampleRinterceptor"
+    result
+  end
+  module ClassMethods
+    def rinter_before(method, *args)
+      p "singleton before -- method: #{method}, args: #{args}  in SubExampleRinterceptor"
+    end
+  end
+  include ExampleRinterceptor
+end
+
+
+
+if __FILE__ == $0
+  
+class TestRinterceptor
+  def i1_test(x, y)
+    p "i1_test x:#{x} y:#{y}"
+  end
+  def i2_test(x, y)
+    p "i2_test x:#{x} y:#{y}"
+  end
+  def i3_test(x, y)
+    p "i3_test x:#{x} y:#{y}"
+  end
+  def self.s_test(x, y)
+    p "s_test x:#{x} y:#{y}"
+  end
+  #set interceptor rules of singleton methods, an alternative way is demonstrated in "self.rinter_before_include_class" of SubExampleRinterceptor
+  #@include_s_methods value example: 
+  #String(for exactly match)
+  #Regexp
+  #[Regexp]
+  #{} (unless key.nil? use rinter_#{key}_around to handle it, otherwise same behavior as before)
+  #refor to SubExampleRinterceptor
+  @include_s_methods = [/^s_/] 
+  include SubExampleRinterceptor
+end
+
+TestRinterceptor.new.i1_test("xxx", "yyy")
+TestRinterceptor.new.i2_test("xxx", "yyy")
+TestRinterceptor.new.i3_test("xxx", "yyy")
+TestRinterceptor.s_test("xxx", "yyy")
+end
+
+

data/lib/rinterceptor.rb

@@ -0,0 +1,178 @@
+=begin
+
+For expandability, Class can not include me directly, only accept Module to include me
+for example:
+
+module MyRinterceptor
+  def instance_method
+  end
+  module ClassMethods #don't change this name if you need singleton method
+    def singleton_method
+    end
+  end
+  include Rinterceptor #should be placed at last line of this module
+end
+
+class YourClass
+  include MyRinterceptor
+end
+
+
+#you can refer to example_rinterceptor.rb
+=end
+#TODO nested interceptor
+module Rinterceptor
+  def self.included(base)
+    raise 'Class can not include me directly, only accept Module to include me' if base.is_a?(Class)
+    base.extend(ClassMethods)
+  end
+
+  #overridable
+  def rinter_skip?
+    false
+  end
+  
+  #overridable
+  def rinter_before(method, *args)
+  end
+  
+  #overridable
+  def rinter_after(method, result, e, *args)
+    raise e unless e.nil?
+    result
+  end
+  
+  #overridable
+  def rinter_around(invocation)
+    invocation.invoke
+  end
+  
+  module ClassMethods
+    #for sub module
+    def included(base)
+      if base.is_a?(Class)
+        rinter_before_include_class(base) #only available in last module for preparing data of Class which will include it
+        base.extend(ClassMethods)
+        base.ancestors[1..-1].reverse.each {|p| base.extend(p::ClassMethods) if p.respond_to?(:rinter_here?)}
+        include_s_methods = base.include_s_methods || []
+        include_i_methods = base.include_i_methods || []
+        include_s_methods = RinterceptorUtil.process_include_methods(include_s_methods)
+        include_i_methods = RinterceptorUtil.process_include_methods(include_i_methods)
+        exclude_s_methods = (base.exclude_s_methods || []) + [/^rinter_/, /include_[is]_methods/, /exclude_[is]_methods/]
+        exclude_i_methods = (base.exclude_i_methods || []) + [/^rinter_/, /include_[is]_methods/, /exclude_[is]_methods/]
+        s_methods = (base.private_methods + base.singleton_methods).delete_if{|m| ! RinterceptorUtil.match_method?(m, include_s_methods, exclude_s_methods) }
+        i_methods = (base.private_instance_methods + base.instance_methods).delete_if{|m| ! RinterceptorUtil.match_method?(m, include_i_methods, exclude_i_methods) }
+        s_methods.each{|m| rinter_generate_proxy(base, m, include_s_methods.is_a?(Hash) ? include_s_methods : nil, true)}
+        i_methods.each{|m| rinter_generate_proxy(base, m, include_i_methods.is_a?(Hash) ? include_i_methods : nil)}
+        rinter_after_include_class(base)  #only available in last module for preparing data of Class which will include it
+      else
+        base.extend(ClassMethods)
+      end
+    end
+    def rinter_here?
+      true
+    end
+    
+    #overridable only in last module
+    def rinter_before_include_class(base)
+    end
+    
+    #overridable only in last module
+    def rinter_after_include_class(base)
+    end
+    
+    def rinter_generate_proxy(obj, method, methods, singleton=false)
+      handler = nil
+      unless methods.nil?
+        methods.each{|k, v| v.each{|vv| if method =~ vv then handler = method; break end }; unless handler.nil? then handler = k.nil? ? nil : "#{k}_"; break end}
+        end
+        obj.class_eval %{
+        #{"class << self" if singleton}
+        alias_method :old4rinter_#{method}, :#{method} unless method_defined?(:old4rinter_#{method})
+        def #{method}(*args)
+          return old4rinter_#{method}(*args) if rinter_skip?
+          rinter_before("#{method}", *args)
+          result = nil
+          e = nil
+          invocation = RinterceptorInvocation.new(self, "#{method}", *args)
+          begin
+            result = rinter_#{handler}around(invocation)
+          rescue => e
+          end
+          rinter_after("#{method}", result, e, *args)
+          result
+        end
+        #{"end" if singleton}
+      }
+      end
+      
+      #target class' methods
+      attr_accessor :include_i_methods
+      attr_accessor :include_s_methods
+      attr_accessor :exclude_i_methods
+      attr_accessor :exclude_s_methods
+
+     #overridable
+     def rinter_skip?
+	false 
+     end
+      
+      #overridable
+      def rinter_before(method, *args)
+      end
+      
+      #overridable
+      def rinter_after(method, result, e, *args)
+        raise e unless e.nil?
+        result
+      end
+      
+      #overridable
+      def rinter_around(invocation)
+        invocation.invoke
+      end
+    end
+  end
+  
+  module RinterceptorUtil
+    def self.match_method?(method, includes, excludes)
+      excludes.each {|i| return false if method =~ i}
+      real_includes = includes.is_a?(Array) ? includes : [] 
+      if includes.is_a?(Hash)
+        includes.each{|k, v| real_includes += v}
+      end
+      real_includes.each {|i| return true if method =~ i}
+      false
+    end
+    def self.process_include_methods(methods)
+      if methods.is_a?(Hash)
+        methods.each do |k, v|
+          if v.is_a?(String) || v.is_a?(Symbol)
+            v = Regexp.new("^#{v}$")
+          elsif v.is_a?(Array)
+            v.each_index{|i| v[i] = Regexp.new("^#{v[i]}$") if v[i].is_a?(String) || v[i].is_a?(Symbol)}
+          end
+          v = [v] if v.is_a?(Regexp)
+          methods[k] = v
+        end
+      end
+      methods
+    end
+  end
+  
+  class RinterceptorInvocation
+    attr_accessor :object, :method, :args, :options
+    def initialize(object, method, *args)
+      @object = object
+      @method = method
+      @args = args
+      @options = {}
+    end
+    def invoke(*args)
+      unless @options.nil? || @options.empty?
+        @args = @args + [@options]
+        @options = nil
+      end
+      @object.send("old4rinter_#{@method}".to_sym, *(args.empty? ? @args : args))
+    end
+  end

metadata

@@ -0,0 +1,57 @@
+--- !ruby/object:Gem::Specification 
+name: rinterceptor
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Leon Li
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-03-09 00:00:00 +08:00
+default_executable: 
+dependencies: []
+
+description: it is a inheritable, reusable AOP framework with regex rule support, let your interceptor simple, flexible and with high expandability
+email: scorpio_leon@hotmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- MIT-LICENSE
+- Rakefile
+- CHANGELOG
+- lib/rinterceptor.rb
+- lib/example_rinterceptor.rb
+has_rdoc: false
+homepage: http://rinter.rubyforge.org/
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: Rinterceptor
+rubygems_version: 1.3.1
+signing_key: 
+specification_version: 2
+summary: it is a inheritable, reusable AOP framework
+test_files: []
+