stub_a 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 022265f955db24a8dd7a3bb3465243121379ecd8
-  data.tar.gz: 86be306baf3ec972fdf4163e7ced3920e7bc4407
+  metadata.gz: c5c160196910a2a2749394b33cf6f8bab32c513b
+  data.tar.gz: 761a09839f11949d5bcafe88cea8828537e7dbf2
 SHA512:
-  metadata.gz: aaff64bee34e4ce474b09fe009188c83af14b39128cd44bbaddc55d8055e4e71a7aeb789d097ae45acc8d685f0890571e8603da53178a7223c4a19a0a1a5c639
-  data.tar.gz: d156071d484adaf0b2be902a1eb7903c33c9b9d2fd0271371e4b472aca42387d2a3b5120703c3256da55ba17357fbd64b0c80ea0bc402a77f5af9023fcadc4ea
+  metadata.gz: 8c1f8f4a27b708b5e80a087e3c911c6380aadfd275453fd24cfc7550a7edadee9625d9a8f09158a1a974448073d689de715db7c54796882ad0feb757f14c1711
+  data.tar.gz: cf1754d3a5414126cacdac2485279405bfcbab2fa8377dbfcaa0be446bcc2a36d3f4dbd6fdf420ce4562676341f65507e7f8b3bb364d6f475429d316b5bd86ae

data/lib/stub_a.rb

@@ -1,35 +1,220 @@
+# coding: utf-8
+
 class StubA
+  # コンストラクタ
+  #
+  # ==詳細
+  # 操作対象のクラスまたはインスタンスを渡し、
+  # 操作用オブジェクトを作成します。
+  #
+  # インスタンスが渡された場合、インスタンス
+  # メソッドに対するフックは特異メソッドとして
+  # 作成されます。
+  #
+  # クラスメソッドは、もともと特異メソッドの
+  # ようなものなので、クラスメソッドに対する操作は
+  # インスタンスを渡してもクラスを渡しても
+  # 変わりません。
+  #
+  # ==引数
+  # - ++object+: クラスまたはインスタンス
   def initialize(object)
-    @target_class = object if object.is_a? Class
-    @target_class ||= class << object; self; end
+    if object.is_a? Class
+      @target = object
+      @target_class = class << object; self; end
+    else
+      @target = class << object; self; end
+      @target_class = class << object.class; self; end
+    end
+  end
+
+  # インスタンスメソッドに対する before フックを作成
+  #
+  # ==詳細
+  # 引数で指定したインスタンスメソッドが実行される
+  # 直前に呼ばれるフックメソッドを作成します。
+  #
+  # 対象のメソッドはメソッド名で指定します。
+  #
+  # ==引数
+  # - ++method_name++: メソッド名
+  #
+  def before(method_name, &block)
+    make_hook(:before, @target, method_name, &block)
   end
 
-  [:before,
-   :after,
-  ].each do |hook_type|
-    define_method hook_type, ->(method, &block) {
-      make_hook_points(method)
+  # クラスメソッドに対する before フックを作成
+  #
+  # ==詳細
+  # 引数で指定したクラスメソッドが実行される直前に
+  # 呼ばれるフックメソッドを作成します。
+  #
+  # 対象のメソッドはメソッド名で指定します。
+  #
+  # ==引数
+  # - ++method_name++: メソッド名
+  #
+  def cbefore(method_name, &block)
+    make_hook(:before, @target_class, method_name, &block)
+  end
 
-      method_name = hook_method_name(method, hook_type)
-      hook = block if block
-      hook ||= default_hook(method, hook_type)
-      @target_class.__send__ :define_method, method_name, hook
-      self
-    }
+  # インスタンスメソッドに対する after フックを作成
+  #
+  # ==詳細
+  # 引数で指定したインスタンスメソッドが実行される
+  # 直後に呼ばれるフックメソッドを作成します。
+  #
+  # 対象のメソッドはメソッド名で指定します。
+  #
+  # ==引数
+  # - ++method_name++: メソッド名
+  #
+  def after(method_name, &block)
+    make_hook(:after, @target, method_name, &block)
+  end
+
+  # クラスメソッドに対する after フックを作成
+  #
+  # ==詳細
+  # 引数で指定したクラスメソッドが実行される直後に
+  # 呼ばれるフックメソッドを作成します。
+  #
+  # 対象のメソッドはメソッド名で指定します。
+  #
+  # ==引数
+  # - ++method_name++: メソッド名
+  #
+  def cafter(method_name, &block)
+    make_hook(:after, @target_class, method_name, &block)
+  end
+
+  # インスタンスメソッドに対するスタブメソッドを作成
+  #
+  # ==詳細
+  # 引数で指定したインスタンスメソッドの代わりに呼ばれる
+  # 代替メソッドを作成します。
+  #
+  # 対象のメソッドはメソッド名で指定します。
+  #
+  # ==引数
+  # - ++method_name++: メソッド名
+  #
+  def stub(method_name, &block)
+    make_stub(@target, method_name, &block)
+  end
+
+  # クラスメソッドに対するスタブを作成
+  #
+  # ==詳細
+  # 引数で指定したクラスメソッドの代わりに呼ばれる代替
+  # メソッドを作成します。
+  #
+  # 対象のメソッドはメソッド名で指定します。
+  #
+  # ==引数
+  # - ++method_name++: メソッド名
+  #
+  def cstub(method_name, &block)
+    make_stub(@target_class, method_name, &block)
   end
 
-  def stub(method, &block)
+  # インスタンスメソッドを書き戻す
+  #
+  # ==詳細
+  # 引数で指定したメソッドに対して行った操作を元に戻します。
+  #
+  # 基本的に、第一引数にメソッド名、第二引数に戻したい操作の
+  # 種類を指定します。
+  #
+  # たとえば、++foo++ というメソッドに対して ++before++
+  # フックを作成した、という操作を戻したい場合は、
+  #
+  #  stub_a.restore(:foo, :before)
+  #
+  # のように指定します。
+  # 第一引数のメソッドに対して、戻したい操作の種類が複数ある
+  # 場合は、
+  #
+  #  stub_a.restore(:foo, :before, :after)
+  #
+  # のように続けて指定することもできます。
+  #
+  # 逆に第二引数を省略した場合は、第一引数で指定したメソッドに
+  # 対して行ったすべての種類の操作を戻します。
+  #
+  # 操作したメソッドがひとつだけの場合で、かつ操作をすべて
+  # 戻して構わない場合は、引数を省略することもできます。
+  #
+  # ==引数
+  # - ++method_name++: メソッド名
+  # - ++types++: 操作の種類
+  #
+  def restore(method_name=nil, *types)
+    restore_hooks(@target, method_name, *types)
+  end
+
+  # クラスメソッドを書き戻す
+  #
+  # ==詳細
+  # ++restore++ がインスタンスメソッドに対する操作であるのに
+  # 対し、++crestore++ はクラスメソッドを操作の対象にします。
+  #
+  # 詳細については、++restore++ の説明を参照してください。
+  #
+  def crestore(method_name=nil, *types)
+    restore_hooks(@target_class, method_name, *types)
+  end
+
+  # すべてのインスタンスメソッドを書き戻す
+  #
+  # ==詳細
+  # インスタンスメソッドに対するすべての操作を書き戻します。
+  #
+  def restore_all
+    restore_all_hooks(@target)
+  end
+
+  # すべてのクラスメソッドを書き戻す
+  #
+  # ==詳細
+  # クラスメソッドに対するすべての操作を書き戻します。
+  #
+  def crestore_all
+    restore_all_hooks(@target_class)
+  end
+
+
+  private
+  METHOD_TYPES = [
+    :before,
+    :after,
+    :stub,
+    :origin,
+  ]
+  private_constant :METHOD_TYPES
+
+  def make_hook(hook_type, target, method, &block)
+    make_hook_points(target, method)
+
+    method_name = hook_method_name(method, hook_type)
+    hook = block if block
+    hook ||= default_hook(method, hook_type)
+    target.__send__ :define_method, method_name, hook
+    self
+  end
+
+  def make_stub(target, method, &block)
     raise ArgumentError, "No block" unless block
-    make_hook_points(method)
+    make_hook_points(target, method)
 
     method_name = hook_method_name(method, :stub)
-    @target_class.__send__ :define_method, method_name, block
+    target.__send__ :define_method, method_name, block
     self
   end
 
-  def restore(method=nil, *types)
+  def restore_hooks(target, method=nil, *types)
     if method.nil?
-      hooks = defined_hooks
+      hooks = defined_hooks(target)
       method = hooks.keys.first if hooks.keys.size == 1
     end
     raise "Method name to be restored is required." if method.nil?
@@ -41,38 +226,29 @@ class StubA
 
     types.each do |type|
       method_name = hook_method_name(method, type)
-      next unless @target_class.method_defined? method_name
-      @target_class.__send__ :remove_method, method_name
+      next unless target.method_defined? method_name
+      target.__send__ :remove_method, method_name
     end
 
-    hooks = defined_hooks
+    hooks = defined_hooks(target)
     if hooks[method.to_s].size == 1 and
       hooks[method.to_s].first == 'origin'
       origin = hook_method_name(method, :origin)
-      @target_class.__send__ :alias_method, method, origin
-      @target_class.__send__ :remove_method, origin
+      target.__send__ :alias_method, method, origin
+      target.__send__ :remove_method, origin
     end
   end
 
-  def restore_all
-    defined_hooks.each do |method, types|
+  def restore_all_hooks(target)
+    defined_hooks(target).each do |method, types|
       types.each do |type|
         name = hook_method_name(method, type)
-        next unless @target_class.method_defined? name
-        @target_class.__send__ :alias_method, method, name if type == 'origin'
-        @target_class.__send__ :remove_method, name
+        next unless target.method_defined? name
+        target.__send__ :alias_method, method, name if type == 'origin'
+        target.__send__ :remove_method, name
       end
     end
   end
-  
-  private
-  METHOD_TYPES = [
-    :before,
-    :after,
-    :stub,
-    :origin,
-  ]
-  private_constant :METHOD_TYPES
 
   def hook_method_name(method, type)
     "===>(stub_a) #{type}-#{method}"
@@ -84,12 +260,12 @@ class StubA
     end
   end
 
-  def make_hook_points(method_name)
+  def make_hook_points(target, method_name)
     methods = hook_method_names(method_name)
-    return if @target_class.method_defined? methods[:origin]
+    return if target.method_defined? methods[:origin]
 
-    @target_class.__send__ :alias_method, methods[:origin], method_name
-    @target_class.__send__ :define_method, method_name, ->(*args, &block) {
+    target.__send__ :alias_method, methods[:origin], method_name
+    target.__send__ :define_method, method_name, ->(*args, &block) {
       if respond_to? methods[:before]
         __send__ methods[:before], ARGS[:before].new(method_name, args), &block
       end
@@ -102,20 +278,19 @@ class StubA
       end
 
       if respond_to? methods[:after]
-        __send__ methods[:after], ARGS[:after].new(method_name, val)
+        __send__ methods[:after], ARGS[:after].new(method_name, args, val)
       end
 
       val
     }
   end
 
-  def defined_hooks
-    re = /\A===>\(stub_a\) (before|after|stub|origin)-(.+)\z/
-    @target_class.instance_methods.each_with_object({}) {|name, h|
-      if name.to_s =~ re
-        h[$2] ||= []
-        h[$2] << $1
-      end
+  def defined_hooks(target)
+    re = /\A===>\(stub_a\) (#{METHOD_TYPES.join('|')})-(.+)\z/
+    target.instance_methods.each_with_object({}) {|name, h|
+      next if name.to_s !~ re
+      h[$2] ||= []
+      h[$2] << $1
     }
   end
 
@@ -129,26 +304,26 @@ class StubA
   end
 
   def default_before_hook(method)
-    ->(method, *args, &block) {
-      puts "[#{Time.now}] call `#{method}' (#{self.inspect})"
-      puts "args: #{args.inspect}" if args.size > 0
+    ->(arg, &block) {
+      puts "[#{Time.now}] call `#{arg.method_name}' (#{self.inspect})"
+      puts "args: #{arg.args.inspect}" if arg.args.size > 0
     }
   end
 
   def default_after_hook(method)
     before_method = hook_method_name(method, :before)
-    ->(method, val) {
+    ->(arg) {
       unless respond_to? before_method
-        puts "[#{Time.now}] call `#{method}' (#{self.inspect})"
+        puts "[#{Time.now}] call `#{arg.method_name}' (#{self.inspect})"
       end
-      puts "return: #{val.inspect}"
+      puts "return: #{arg.return_value.inspect}"
     }
   end
 
   ARGS = {
     before: Struct.new(:method_name, :args),
     stub: Struct.new(:method, :args),
-    after: Struct.new(:method_name, :return_value),
+    after: Struct.new(:method_name, :args, :return_value),
   }
   private_constant :ARGS
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: stub_a
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - 60ml