method_wrapper 0.1.1 → 0.2.0

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    method_wrapper (0.1.1)
+    method_wrapper (0.2.0)
 
 GEM
   remote: http://rubygems.org/
@@ -25,4 +25,3 @@ DEPENDENCIES
   bundler (>= 1.0.0.rc.5)
   method_wrapper!
   rspec (>= 2.0.0)
-

data/README.rdoc

@@ -4,71 +4,60 @@
 
 == Introduction
 
-This gem helps you to wrap new features around (before and after) existing methods call on any classes.
-
-The before_ and after_ callbacks will run as soon as you call wrapped method.
+alias_method_chain alternative. How easy to wrap new features around existing methods with method_wrapper.
 
 == Installation
 
   gem install method_wrapper
 
 == Examples
-  require 'method_wrapper'
-
-  class Klass
-    include MethodWrapper
-    wrap_methods :method_name
-
-    def method_name
-      puts 'hi'
-    end
-
-    def before_method_name
-      puts "calls before method name"
-    end
 
-    def after_method_name
-      puts "calls after method name"
-    end
-  end
-
-You can also has partial callback
+* Wrap multi methods to a feature in a line.
+* Be able to call wrap_methods before methods defined.
   require 'method_wrapper'
+* Call original method(origin_method_name). Note: I take different style from alias_method_chain because we don't want users to know what feature has been wrapped.
+
+== Examples
 
   class Klass
     include MethodWrapper
-    wrap_methods :method_name, :second_method_name
+    wrap_methods [:save!, :query] => :log
 
-    def method_name
-      puts 'hi'
+    def save!
+      "save"
     end
 
-    def second_method_name
-      puts 'hello'
+    def query
+      "update"
     end
 
-    def before_method_name
-      puts "calls before method name"
+    def save_with_log!
+      origin_save! + " with log"
     end
 
-    def after_method_name
-      puts "calls after method name"
-    end
-
-    def after_second_method_name
-      puts "calls after second method name"
+    def query_with_log
+      origin_query! + " with log"
     end
   end
 
-You can also open the existing classes to wrap methods
+  obj = Klass.new
+  obj.save!
+   => "save with log"
+  obj.origin_save!
+   => "save"
+
+You can also open the existing classes to wrap methods. Note: Be careful, you know what you are doing.
   require 'method_wrapper'
 
   class String
     include MethodWrapper
-    wrap_methods :reverse
+    wrap_methods :reverse => :upcase
 
-    def before_reverse
-      puts "calls before string reverse"
+    def reverse_with_upcase
+      origin_reverse.upcase
     end
   end
 
+  "nuhhc gnanmas".reverse
+   => SAMNANG CHHUN
+

data/lib/method_wrapper.rb

@@ -1,51 +1,88 @@
 module MethodWrapper
   def self.included(base)
-    base.instance_variable_set(:@_wrapped_methods, [])
+    base.instance_variable_set(:@__wrapped_methods, {})
     base.extend ClassMethods
   end
 
-  private
-  def invoke_method(name)
-    send(name) if respond_to? name, true
-  end
-
   module ClassMethods
+    def wrap_methods(params)
+      method_names, feature = params.first
+      method_names = [method_names] unless method_names.instance_of? Array
+
+      method_names.each do |name|
+        feature_name = feature_method_name(name, feature)
+        @__wrapped_methods[name] = feature_name
+
+        __wrap_method!(name, feature_name)
+      end
+    end
+
     def method_added(name)
-      return if @_disable_hook_method_added
+      return if @disable_method_added_hook
 
-      _wrap_method!(name) if @_wrapped_methods.include? name
+      new_added_method_has_in_wrpped_methods(name)
     end
 
-    def wrap_methods(*args)
-      @_wrapped_methods = args
+    def include(*modules)
+      super
 
-      @_wrapped_methods.each do |name|
-        _wrap_method!(name) if instance_method_defined? name
+      @__wrapped_methods.each do |k, v|
+        __wrap_method!(k, v)
       end
     end
 
     private
-    def _wrap_method!(name)
-      @_disable_hook_method_added = true
+    def __wrap_method!(name, feature_name)
+      return unless methods_have_already_defined?(name, feature_name)
+
+      origin_name = origin_method_name(name)
 
-      origin_method_name = "origin_#{name}"
-      origin_method = instance_method(name)
+      @disable_method_added_hook = true
 
-      alias_method origin_method_name, name
+      alias_method origin_name, name
+      alias_method name, feature_name
 
-      define_method(name) do |*args, &block|
-        invoke_method("before_#{name}")
-        return_result = origin_method.bind(self).call(*args, &block)
-        invoke_method("after_#{name}")
+      @disable_method_added_hook = false
 
-        return_result
+      [:public, :protected, :private].each do |v|
+        send(v, name) if send("#{v}_method_defined?", origin_name)
       end
+    end
+
+    def feature_method_name(name, feature)
+      name = name.to_s
+      feature_name = name.end_with?("!", "?", "=") ?
+                              "#{name[0..-2]}_with_#{feature}#{name[-1]}" :
+                              "#{name}_with_#{feature}"
 
-      @_disable_hook_method_added = false
+      feature_name.to_sym
     end
 
-    def instance_method_defined?(name)
-      instance_methods.include? name.to_sym
+    def origin_method_name(name)
+      "origin_#{name}"
+    end
+
+
+    def methods_have_already_defined?(*args)
+      args.each {|name| return false unless all_instance_methods.include? name }
+
+      true
+    end
+
+    def all_instance_methods
+      public_instance_methods +
+      protected_instance_methods +
+      private_instance_methods
+    end
+
+    def new_added_method_has_in_wrpped_methods(name)
+      if @__wrapped_methods.has_key? name
+        feature_name = @__wrapped_methods[name]
+        __wrap_method!(name, feature_name)
+      elsif @__wrapped_methods.has_value? name
+        name, feature_name = @__wrapped_methods.select{|k, v| v == name }.first
+        __wrap_method!(name, feature_name)
+      end
     end
   end
 end

data/lib/method_wrapper/version.rb

@@ -1,4 +1,4 @@
 module MethodWrapper
-  VERSION = "0.1.1"
+  VERSION = "0.2.0"
 end
 

data/method_wrapper.gemspec

@@ -9,8 +9,8 @@ Gem::Specification.new do |s|
   s.authors     = ["Samnang Chhun"]
   s.email       = ["samnang.chhun@gmail.com"]
   s.homepage    = "http://github.com/samnang/method_wrapper"
-  s.summary     = "How easy to wrap new features around (before and after) existing methods call with method_wrapper."
-  s.description = "This gem helps you to wrap new features around (before and after) existing methods call on any classes. The before_ and after_ callbacks will run as soon as you call wrapped method."
+  s.summary     = "Alternative alias_method_chain. How easy to wrap new features around existing methods with method_wrapper."
+  s.description = "alias_method_chain alternative. How easy to wrap new features around existing methods with method_wrapper."
 
   s.required_rubygems_version = ">= 1.3.6"
   s.rubyforge_project         = "[none]"

data/spec/class_builder.rb

@@ -1,81 +1,40 @@
 class ClassBuilder
   class << self
-    def a_class_has_methods_and_calls_after_methods_defined
-      Class.new do
-        include MethodWrapper
-
-        def method_name
-        end
-
-        def second_method_name
-        end
-
-        wrap_methods :method_name, :second_method_name
-      end
-    end
-
-    def a_class_has_methods_and_calls_before_methods_defined
-      Class.new do
-        include MethodWrapper
-        wrap_methods :method_name, :second_method_name
+    module Methods
+      def name!; end
+      def name1; end
 
-        def method_name
-        end
+      def name_with_feature!; end
+      def name1_with_feature; end
 
-        def second_method_name
-        end
-      end
+      private :name1
     end
 
-    def a_class_has_before_and_after_wrap_methods
+    def a_class_with_2_methods_add_feature
       Class.new do
         include MethodWrapper
-        wrap_methods :method_name
-
-        def method_name
-        end
+        include Methods
 
-        private
-        def before_method_name
-          @has_called_before_callback = true
-        end
-
-        def after_method_name
-          @has_called_after_callback = true
-        end
+        wrap_methods :name! => :feature
+        wrap_methods :name1 => :feature
       end
     end
 
-    def a_class_has_partial_callback
+    def a_class_calls_wrap_methods_with_array_of_methods
       Class.new do
         include MethodWrapper
+        include Methods
 
-        def method_name
-        end
-
-        private
-        def before_method_name
-          @has_called_before_callback = true
-        end
-
-        wrap_methods :method_name
+        wrap_methods [:name!, :name1] => :feature
       end
     end
 
-    def a_class_has_method_with_args_and_block
+    def a_class_calls_wrap_methods_before_methods_defined
       Class.new do
         include MethodWrapper
-        wrap_methods :method_name
-
-        def method_name(param)
-          @param = param
-          yield
-        end
+        wrap_methods [:name!, :name1] => :feature
 
-        private
-        def after_method_name
-          @has_called_after_callback = true
-        end
+        include Methods
       end
     end
   end

data/spec/method_wrapper_spec.rb

@@ -1,57 +1,46 @@
 require 'spec_helper'
 
 describe MethodWrapper do
-  describe ".wrap_methods, stores methods that want to wrap" do
-    it "calls after method defined" do
-      klass = ClassBuilder.a_class_has_methods_and_calls_after_methods_defined
+  describe ".wrap_methods" do
+    let(:klass) { klass = ClassBuilder.a_class_with_2_methods_add_feature }
 
+    it "should stores the wrapped methods with feature" do
       verify_wrapped_methods(klass)
     end
 
-    it "calls before method defined" do
-      klass = ClassBuilder.a_class_has_methods_and_calls_before_methods_defined
+    it "should be able call wrap_methods with array of method" do
+      klass = ClassBuilder.a_class_calls_wrap_methods_with_array_of_methods
 
       verify_wrapped_methods(klass)
     end
 
-    def verify_wrapped_methods(klass)
-      klass.instance_variable_get(:@_wrapped_methods).should ==
-        [:method_name, :second_method_name]
+    it "should wrap new feature to methods" do
+      verify_alias_methods(klass)
     end
-  end
-
-  context "invoke the wrapped methods" do
-    it "should invoke _before_method_name and after_method_name" do
-      klass = ClassBuilder.a_class_has_before_and_after_wrap_methods
-      obj = klass.new
-
-      obj.method_name
 
-      obj.instance_variable_get(:@has_called_before_callback).should eql(true)
-      obj.instance_variable_get(:@has_called_after_callback).should eql(true)
+    it "should create new method for origin method" do
+      klass.new.should be_respond_to :origin_name!
+      klass.new.should be_respond_to :origin_name1, true #include private
     end
 
-    it "should ignore callbacks if user hasn't defined" do
-      klass = ClassBuilder.a_class_has_partial_callback
-      obj = klass.new
+    it "should restore visibility to origin method" do
+      klass.private_instance_methods.should include(:name1)
+    end
 
-      obj.method_name
+    it "should be able to calls before methods defined" do
+      klass = ClassBuilder.a_class_calls_wrap_methods_before_methods_defined
 
-      obj.instance_variable_get(:@has_called_before_callback).should eql(true)
+      verify_alias_methods(klass)
     end
 
-    it "should be able to invoke the method with args and block" do
-      klass = ClassBuilder.a_class_has_method_with_args_and_block
-      obj = klass.new
-      has_called = false
-
-      obj.method_name("value") do
-        has_called = true
-      end
+    def verify_wrapped_methods(klass)
+      klass.instance_variable_get(:@__wrapped_methods).should ==
+        {:name! => :name_with_feature!, :name1 => :name1_with_feature}
+    end
 
-      obj.instance_variable_get(:@param).should eql("value")
-      has_called.should eql(true)
-      obj.instance_variable_get(:@has_called_after_callback).should eql(true)
+    def verify_alias_methods(klass)
+      klass.should has_alias_method(:name!, :name_with_feature!)
+      klass.should has_alias_method(:name1, :name1_with_feature)
     end
   end
 end

data/spec/spec_helper.rb

@@ -3,3 +3,9 @@ require 'rspec'
 require_relative 'class_builder'
 require_relative '../lib/method_wrapper.rb'
 
+RSpec::Matchers.define :has_alias_method do |first, second|
+  match do |klass|
+    klass.instance_method(first).should == klass.instance_method(second)
+  end
+end
+

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
-  - 1
-  - 1
-  version: 0.1.1
+  - 2
+  - 0
+  version: 0.2.0
 platform: ruby
 authors: 
 - Samnang Chhun
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-10-30 00:00:00 +07:00
+date: 2010-11-01 00:00:00 +07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -49,7 +49,7 @@ dependencies:
         version: 2.0.0
   type: :development
   version_requirements: *id002
-description: This gem helps you to wrap new features around (before and after) existing methods call on any classes. The before_ and after_ callbacks will run as soon as you call wrapped method.
+description: alias_method_chain alternative. How easy to wrap new features around existing methods with method_wrapper.
 email: 
 - samnang.chhun@gmail.com
 executables: []
@@ -103,6 +103,6 @@ rubyforge_project: "[none]"
 rubygems_version: 1.3.7
 signing_key: 
 specification_version: 3
-summary: How easy to wrap new features around (before and after) existing methods call with method_wrapper.
+summary: Alternative alias_method_chain. How easy to wrap new features around existing methods with method_wrapper.
 test_files: []