rhook 0.1.5 → 0.1.6

data/.yardopts

@@ -0,0 +1,2 @@
+--no-private
+--title "rhook"

data/README.rdoc

@@ -1,9 +1,16 @@
 = rhook - Easily drive AOP & hacking existing library with Ruby
 
+- Homepage & Source --  http://github.com/kaorukobo/rhook
+- Download -- http://rubygems.org/gems/rhook
+- API Documentation (RDoc) -- http://rubydoc.info/github/kaorukobo/rhook/master/frames
+
+== Summary
+
 - You can provide hook point in your code,
   - and can customize its behavior from outside.
 - Also you can 'hack' (== injecting hook point from outside) any methods in existing code. 
 
+
 == Install
 
   gem install rhook
@@ -65,20 +72,21 @@
 
 === about '_rhook'
 
-Once you require 'rhook', any objects has '_rhook' method to access any rhook services. (that returns RHook::RHookService object.)
+Once you require 'rhook', any objects has '_rhook' method to access any rhook services. (that returns {RHook::RHookService} object.)
 
     any_object = Object.new
     any_object._rhook.RHOOK_METHOD
 
+See http://rubydoc.info/github/kaorukobo/rhook/master/RHook/RHookService
+
 === What is 'inv' ?
 
-RHook::Invocation object, that contains:
+{RHook::Invocation} object, that contains:
 
 - call() method to proceed method invocation.
-- receiver
-- arguments passed to method
-- blocks passed to method
-- returned value by call()
+- receiver, arguments/blcoks passed to method, and the other informations. See {RHook::Invocation}.
+
+See http://rubydoc.info/github/kaorukobo/rhook/master/RHook/Invocation
 
 === If you want 'bind' to not only an object, but any instances of class:
 
@@ -113,6 +121,16 @@ for class method:
 
 Please see spec: http://github.com/kaorukobo/rhook/blob/master/spec/rhook_spec.rb
 
+== Practical Examples
+
+=== 1. Log Buffer
+
+Log Buffer allows you to capture any messages written to Logger and keep in buffer.
+
+For example, you can examine the target program's log messages in testing code.
+
+http://github.com/kaorukobo/rhook/blob/master/spec/examples/log_buffer_example_spec.rb
+
 == ...
 
 === Note on Patches/Pull Requests

data/Rakefile

@@ -1,6 +1,9 @@
 require 'rubygems'
 require 'rake'
 
+require "logger"
+log = Logger.new(STDERR)
+
 begin
   require 'jeweler'
   Jeweler::Tasks.new do |gem|
@@ -11,6 +14,8 @@ begin
     gem.homepage = "http://github.com/kaorukobo/rhook"
     gem.authors = ["Kaoru Kobo"]
     gem.add_development_dependency "rspec", ">= 1.2.9"
+    gem.add_development_dependency "yard", "~> 0.6.0"
+    gem.has_rdoc = "yard"
     # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
   end
   Jeweler::GemcutterTasks.new
@@ -34,12 +39,11 @@ task :spec => :check_dependencies
 
 task :default => :spec
 
-require 'rake/rdoctask'
-Rake::RDocTask.new do |rdoc|
-  version = File.exist?('VERSION') ? File.read('VERSION') : ""
-
-  rdoc.rdoc_dir = 'rdoc'
-  rdoc.title = "rhook #{version}"
-  rdoc.rdoc_files.include('README*')
-  rdoc.rdoc_files.include('lib/**/*.rb')
+begin
+  gem "yard"
+  require "yard"
+  YARD::Rake::YardocTask.new do |t|
+  end
+rescue Gem::LoadError
+  log.warn "Install YARD to generate document."
 end

data/VERSION

@@ -1 +1 @@
-0.1.5
+0.1.6

data/examples/log_socket_data.rb

@@ -0,0 +1,34 @@
+require "socket"
+
+require "rubygems"
+require "rhook"
+
+# Trace TCPSocket output data.
+TCPSocket._rhook.hack(:write) do |inv|
+  STDERR.print("> ", inv.args[0].inspect, "\n")
+  inv.call
+end
+
+# Trace TCPSocket input data.
+TCPSocket._rhook.hack(:read) do |inv|
+  inv.call
+  STDERR.print("< ", inv.returned.inspect, "\n")
+  inv.returned
+end
+
+
+require "rack"
+require "rack/handler/webrick"
+
+th = Thread.start {
+  Rack::Handler::WEBrick.run(lambda { |env|
+    [200, {}, []]
+  }, :Port => 9292)
+}
+sleep 1
+
+sock = TCPSocket.new("localhost", 9292)
+sock.print("GET / HTTP/1.0\n\n")
+sock.flush
+
+sock.read

data/lib/rhook.rb

@@ -1,4 +1,7 @@
 module RHook
+  # @private
+  # The registry contains information globally shared. (like cache)
+  # You don't need to use this class.
   class Registry
     attr_reader :class_cached_flag_map
     def initialize
@@ -6,19 +9,44 @@ module RHook
     end
   end
   
+  # @private
+  # Get global +Registry+ object.
   def self.registry
     @registry ||= Registry.new
   end
   
+  # Most important class on rhook.
+  # 
+  # If you call obj._rhook, it returns a RHookService object bound to +obj+. 
   class RHookService
+    # @private
     attr_reader :hooks_map
     
+    # @private
     def initialize(obj)
       @obj = obj
       @hooks_map = {}
       @class_cached_hooks_map = {} if Class === @obj
     end
     
+    # Returns the object bound to this RHookService.
+    # ( +obj+ of +obj._rhook+ ) 
+    def bound_object
+      @obj
+    end
+    
+    # ========================================================================
+    # @group Methods for hook-side(outside)
+    # ========================================================================
+
+    # Add hook to the {#bound_object}. If it is a kind of Class, the hook is affected to all instance & subclasses of the class.
+    # 
+    # @param [Symbol] name hook-point's name (commonly equals to method name)
+    # @option opt [true] :disable Create hook but make disabled. (by default, automatically enabled.)
+    # @yield [inv] The hook block.
+    # @yieldparam [Invocation] inv
+    # @yieldreturn The result value. (Returned value of called method.)
+    # @return [Hook] Created hook.
     def bind(name, opt = {}, &block)
       hook = Hook.new
       hook.hook_proc = block
@@ -29,6 +57,15 @@ module RHook
       hook
     end
     
+    # Injects hook-point (hack) to the paticular method in {#bound_object}, and add hook same as {#bind}.
+    #
+    # The hook-point injection is done by 'alias' method.
+    # If the hook-point is already injected, this just does {#bind}.
+    #
+    # @param [Symbol] name    The name of method to hack.
+    # @yield [inv]
+    # @return [Hook]
+    # @see #bind See #bind for other param/return.
     def hack(name, opt = {}, &block)
       success = false
       if Class === @obj
@@ -44,13 +81,21 @@ module RHook
       bind(name, opt, &block)
     end
     
+    # @group Methods for hook-side(outside)
+    # 
+    # Unbind all hooks bound to {#bound_object}.
+    # @return [self]
     def unbind_all
       @hooks_map.clear
       @class_cached_hooks_map.clear
+      self
     end
     
-    # nodoc:
-    # Proxy class for 'to'
+    # ========================================================================
+    # @endgroup
+    # ========================================================================
+
+    # @private
     class Caller
       def initialize(rhook, opt)
         @rhook = rhook
@@ -62,13 +107,22 @@ module RHook
       end
     end #/Caller
     
-    # ================================================================
-    # Target-side methods:
-    
+    # ========================================================================
+    # @group Methods for target-side (for providing hook-point)
+    # ========================================================================
+
+    # Wraps {#bound_object}'s method call to be hookable.
+    #
+    # @example 
+    #   _rhook.to.method_name(arg1, arg2)
+    #
+    # @option opt [Hash] :hint Hint values used through {Invocation#hint}.
+    # @return Proxy to call method.
     def to(opt = {})
       Caller.new(self, opt)
     end
     
+    # @private
     def call_method(name, method_name, args, block, opt = {})
       hooks = concat_hooks([], name)
       hooks.empty? and return @obj.__send__(method_name, *args, &block)
@@ -84,6 +138,15 @@ module RHook
       inv.proceed()
     end
     
+    # Wraps the code block to be hookable.
+    #
+    # @example
+    #   _rhook.does(:hook_name) { do_something; }
+    #
+    # @param [Symbol] name The hook-point's name specified on {#bind}.
+    # @option opt [Hash] :hint Hint values used through {Invocation#hint}.
+    # @yield The code block to be hooked.
+    # @return The result of code block. (Replaced if it is changed by hook.)
     def does(name, opt = {}, &block)
       hooks = concat_hooks([], name)
       hooks.empty? and return yield
@@ -99,6 +162,18 @@ module RHook
       inv.proceed()
     end
     
+    # Wraps the defined method to be hookable.
+    # 
+    # If possible, using {#to} is recommended than {#on_method}, because if the subclass override the hookable method, the subclasse's code become out of hook target.
+    #
+    # @example
+    #   on_method :method_name
+    #
+    # @overload on_method(*names, opt = {})
+    #   @param [Symbol] names The method name(s).
+    #   @option opt [Boolean] :ifdef If true, it doesn't raise error whenever the method is not defined.
+    # @raise [NameError] If the method is not defined.
+    # @return [Boolean] When :ifdef => true, returns sucess or not, otherwise always true.
     def on_method(*names_and_opt)
       success = true
       
@@ -122,9 +197,11 @@ module RHook
       success
     end
     
-    # ================================================================
-    # Internal methods:
-    
+    # ========================================================================
+    # @endgroup
+    # ========================================================================
+
+    # @private
     def concat_hooks(dest, name)
       if Class === @obj
         concat_class_hooks(dest, name)
@@ -135,6 +212,7 @@ module RHook
       dest
     end
     
+    # @private
     def concat_class_hooks(dest, name)
       # use cached one if available
       if RHook.registry.class_cached_flag_map[name]
@@ -145,7 +223,7 @@ module RHook
       end
       
       hooks = []
-
+      
       # collect hooks including ancestor classes
       begin
         concat_hooks_internal(hooks, name)
@@ -168,25 +246,39 @@ module RHook
       dest.concat(hooks)
     end
     
+    # @private
     def concat_hooks_internal(dest, name)
       hooks = @hooks_map[name]
       hooks and dest.concat(hooks)
     end
   end #/RHookService
   
+  # The object contains the invocation information.
+  #
+  # @attr_reader [Object] target The target object that the hook is applied. (Usually same to {#receiver})
+  # @attr_reader [Object] receiver The receiver object of this method invocation.
+  # @attr [Array<Object>] args The arguments given to the method invocation. 
+  # @attr [Proc] block The block given to the method invocation
+  # @attr_reader [Object] returned The returned value by the method invocation. (Don't set this. To change it, just return by the alternative value from the hook procedure.) 
+  # @attr_reader [Array<Hook>] hooks (Internally used) The applied hooks on this invocation.
+  # @attr [Proc] target_proc (Internally used) The procedure to execute the target method/procedure.
+  # @attr [Hash] hint Hint data given by {RHookService#does} / {RHookService#to}.
   class Invocation < Struct.new(:target, :receiver, :args, :block, :returned, :hooks, :target_proc, :hint)
+    # @private
     def initialize
       @hook_index = 0
     end
     
+    # Proceed to execute the next one on hooks-chain. If no more hooks, execute the target method/procedure.
+    # @return The returned value from the target method/procedure. (may changed by hook)
     def proceed
       hook = hooks[@hook_index]
       # -- If no more hook was found, calls target procedure and return
-      hook or return target_proc.call(*args, &block)
+      hook or return self.returned = target_proc.call(*args, &block)
       # -- Set hook pointer to next, then call next hook
       @hook_index += 1
       begin
-        hook.call(self)
+        self.returned = hook.call(self)
       ensure
         @hook_index -= 1
       end
@@ -195,15 +287,26 @@ module RHook
     alias call proceed
   end #/Invocation
   
+  # The registered hook instance returned by #{RHookService#bind}.
   class Hook
+    # Whether this hook is enabled.
+    # @return [Boolean] 
     attr_accessor :enabled
+    # The hook procedure registered by {RHookService#bind}.
+    # @return [Proc] 
     attr_accessor :hook_proc
     
+    # @private
     def call(inv)
       @enabled or return inv.proceed()
       hook_proc.call(inv)
     end
     
+    # Enable this hook.
+    # @overload enable()
+    # @overload enable(&block)
+    # @yield If block was given, the hook is enabled only within the given code block. (Note: This is not thread-safe.)
+    # @return [self]
     def enable(&block)
       @enabled = true
       if block_given?
@@ -216,31 +319,47 @@ module RHook
       self
     end
     
+    # Disable this hook.
+    # @return [self]
     def disable
       @enabled = false
       self
     end
   end #/Hook
   
+  # 
   class ::Object
+    # Get {RHook::RHookService} object bound to this object.
+    # @return [RHook::RHookService]
     def _rhook
       @_rhook ||= RHook::RHookService.new(self)
     end
     
+    # @private
     def _has_rhook?
       @_rhook ? true : false
     end
   end
   
+  # Object to group the hooks for the certain purpose.
+  # You can enable/disable the grouped hooks at once.
+  #
+  # Don't instantiate this class. Use {RHook.group} method.
   class HookGroup
+    # @private
     def initialize
       @hooks = []
     end
     
+    # Add a new hook to this group.
+    # @return [self]
     def add(hook)
       @hooks << hook
+      self
     end
     
+    # Add any hooks to this group that was registered by #{RHookService#bind} in the given block code.
+    # @return [self]
     def wrap(&block)
       group_stack = (Thread.current["rhook_group"] ||= [])
       group_stack << self 
@@ -252,6 +371,9 @@ module RHook
       self
     end
     
+    # Enable the hooks.
+    # @return [self]
+    # @see Hook#enable
     def enable(&block)
       @hooks.each do |h|
         h.enable
@@ -266,6 +388,9 @@ module RHook
       self
     end
     
+    # Disable the hooks.
+    # @return [self]
+    # @see Hook#disable
     def disable
       @hooks.each do |h|
         h.disable
@@ -273,13 +398,24 @@ module RHook
       self
     end
     
+    # @private
     def self.add_to_current_groups(hook)
-      (Thread.current["rhook_group"] || []).each do |group|
+     (Thread.current["rhook_group"] || []).each do |group|
         group.add(hook)
       end
     end
   end #/HookGroup
   
+  # Create the {HookGroup}, and add any hooks to this group that was registered by #{RHookService#bind} in the given block code.
+  # 
+  # @example
+  #   XXX_feature_for_library = RHook.group {
+  #     Target._rhook.bind(...) {...}
+  #     Target2._rhook.bind(...) {...}
+  #   }
+  #   XXX_feature_for_library.disable
+  # 
+  # @return [HookGroup]
   def self.group(&block)
     HookGroup.new.wrap(&block)
   end

data/rhook.gemspec

@@ -1,44 +1,48 @@
 # Generated by jeweler
 # DO NOT EDIT THIS FILE DIRECTLY
-# Instead, edit Jeweler::Tasks in rakefile, and run the gemspec command
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
 # -*- encoding: utf-8 -*-
 
 Gem::Specification.new do |s|
   s.name = %q{rhook}
-  s.version = "0.1.5"
+  s.version = "0.1.6"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Kaoru Kobo"]
-  s.date = %q{2010-11-12}
+  s.date = %q{2010-12-01}
   s.description = %q{You can provide hook point in your code, and can customize its behavior from outside. Also you can 'hack' (== injecting hook point from outside) any methods in existing code.}
   s.email = %q{}
   s.extra_rdoc_files = [
     "LICENSE",
-     "README.rdoc"
+    "README.rdoc"
   ]
   s.files = [
     ".document",
-     ".gitignore",
-     "LICENSE",
-     "README.rdoc",
-     "Rakefile",
-     "VERSION",
-     "lib/rhook.rb",
-     "rhook.gemspec",
-     "spec/rhook_minor_spec.rb",
-     "spec/rhook_spec.rb",
-     "spec/spec.opts",
-     "spec/spec_helper.rb"
+    ".yardopts",
+    "LICENSE",
+    "README.rdoc",
+    "Rakefile",
+    "VERSION",
+    "examples/log_socket_data.rb",
+    "lib/rhook.rb",
+    "rhook.gemspec",
+    "spec/examples/log_buffer_example_spec.rb",
+    "spec/rhook_minor_spec.rb",
+    "spec/rhook_spec.rb",
+    "spec/spec.opts",
+    "spec/spec_helper.rb"
   ]
+  s.has_rdoc = %q{yard}
   s.homepage = %q{http://github.com/kaorukobo/rhook}
-  s.rdoc_options = ["--charset=UTF-8"]
   s.require_paths = ["lib"]
   s.rubygems_version = %q{1.3.7}
   s.summary = %q{Easily drive AOP & hacking existing library with Ruby}
   s.test_files = [
+    "examples/log_socket_data.rb",
+    "spec/examples/log_buffer_example_spec.rb",
     "spec/rhook_minor_spec.rb",
-     "spec/rhook_spec.rb",
-     "spec/spec_helper.rb"
+    "spec/rhook_spec.rb",
+    "spec/spec_helper.rb"
   ]
 
   if s.respond_to? :specification_version then
@@ -47,11 +51,14 @@ Gem::Specification.new do |s|
 
     if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
       s.add_development_dependency(%q<rspec>, [">= 1.2.9"])
+      s.add_development_dependency(%q<yard>, ["~> 0.6.0"])
     else
       s.add_dependency(%q<rspec>, [">= 1.2.9"])
+      s.add_dependency(%q<yard>, ["~> 0.6.0"])
     end
   else
     s.add_dependency(%q<rspec>, [">= 1.2.9"])
+    s.add_dependency(%q<yard>, ["~> 0.6.0"])
   end
 end
 

data/spec/examples/log_buffer_example_spec.rb

@@ -0,0 +1,66 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe "rhook examples" do
+  describe "log buffer (hack Logger)" do
+    require "logger"
+    
+    # Captures any messages written to Logger and keep in buffer.
+    # You can read captured messages by LogBuffer#get 
+    # or LogBuffer##pull ( also clears buffer ). 
+    class LogBuffer
+      def initialize
+        @buf = ""
+        # Any log messages are passed to Logger#format_message. Hack it!!
+        Logger._rhook.hack(:format_message) do |inv|
+          result = inv.call
+          @buf << result
+          result
+        end
+      end
+      
+      def clear
+        @buf = ""
+      end
+      
+      def get
+        @buf
+      end
+      
+      def pull
+        result = get()
+        clear()
+        result
+      end
+    end #/LogBuffer
+    
+    # The example application to test.
+    # You cannot know whether it success or failed, (by return value or exception)
+    # ... it only logs.
+    class TargetApp
+      def initialize
+        @log = Logger.new(STDERR)
+      end
+      
+      def success
+        @log.info "Success!"
+      end
+      
+      def fail
+        @log.error "Failed!"
+      end
+    end
+    
+    example "Use LogBuffer to write test" do
+      app = TargetApp.new
+      
+      # start to capture log.
+      logbuf = LogBuffer.new
+      
+      app.success
+      logbuf.pull.should match(/Success!/)
+      
+      app.fail
+      logbuf.pull.should match(/Failed!/)
+    end
+  end
+end

data/spec/rhook_spec.rb

@@ -216,6 +216,51 @@ describe "rhook (advanced usage)" do
   end
   # ================================================================
   
+  # ========================================================================
+  describe "Invocation object" do
+    class Target
+      def invocation_object(*args, &block)
+        _rhook.to(:hint => {:hintkey => :hintval}).invocation_object_target(*args, &block)
+      end
+      
+      def invocation_object_target(*args, &block)
+        :returned_value
+      end
+    end #/Target
+    
+    example "attributes" do
+      args = [1, 2]
+      block = lambda do
+        
+      end
+      
+      lambda { |called|
+        t = Target.new
+        t._rhook.bind(:invocation_object_target) { |inv|
+          # first hook
+          called.yes
+          inv.call()
+          inv.returned.should == :returned_value
+          :returned_value_hooked
+        }
+        t._rhook.bind(:invocation_object_target) { |inv|
+          # second hook
+          called.yes
+          inv.args.should == args
+          inv.block.should == block
+          inv.hint[:hintkey].should == :hintval
+          inv.receiver.should == t
+          inv.target.should == t
+          inv.returned.should be_nil
+          inv.call()
+          inv.returned.should == :returned_value_hooked
+        }
+        t.invocation_object(*args, &block)
+      }.should calls_hook(:times => 2)
+    end
+  end
+  # ========================================================================
+  
 end
 
 # ================================================================

data/spec/spec_helper.rb

@@ -1,5 +1,5 @@
 require 'rubygems'
-gem 'rspec'
+gem 'rspec', "< 2.0"
 
 $LOAD_PATH.unshift(File.dirname(__FILE__))
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
@@ -10,3 +10,45 @@ require 'spec/autorun'
 Spec::Runner.configure do |config|
   
 end
+
+# ========================================================================
+# Defines custom matcher to test the hook was called.
+
+module ::Spec::Matchers
+  class HookCalledMatcher
+    def initialize(opt)
+      @times = opt[:times]
+      @count = 0
+    end
+    
+    def yes
+      @count += 1
+    end
+    
+    def matches?(block)
+      block.call(self)
+      if @times
+        begin
+          @count.should == @times
+        rescue
+          @times_msg = " (Exactly called count: #{$!})"
+          false
+        end
+      else
+        @count > 0
+      end
+    end
+    
+    def failure_message
+      "Expected the hook to be called.#{@times_msg}"
+    end
+    
+    def negative_failure_message
+      "Expected the hook not to be called.#{@times_msg}"
+    end
+  end
+  
+  def calls_hook(opt = {})
+    HookCalledMatcher.new(opt)
+  end
+end

metadata

@@ -1,12 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: rhook
 version: !ruby/object:Gem::Version 
+  hash: 23
   prerelease: false
   segments: 
   - 0
   - 1
-  - 5
-  version: 0.1.5
+  - 6
+  version: 0.1.6
 platform: ruby
 authors: 
 - Kaoru Kobo
@@ -14,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-11-12 00:00:00 +09:00
+date: 2010-12-01 00:00:00 +09:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -25,6 +26,7 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        hash: 13
         segments: 
         - 1
         - 2
@@ -32,6 +34,22 @@ dependencies:
         version: 1.2.9
   type: :development
   version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: yard
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 0
+        - 6
+        - 0
+        version: 0.6.0
+  type: :development
+  version_requirements: *id002
 description: You can provide hook point in your code, and can customize its behavior from outside. Also you can 'hack' (== injecting hook point from outside) any methods in existing code.
 email: ""
 executables: []
@@ -43,24 +61,26 @@ extra_rdoc_files:
 - README.rdoc
 files: 
 - .document
-- .gitignore
+- .yardopts
 - LICENSE
 - README.rdoc
 - Rakefile
 - VERSION
+- examples/log_socket_data.rb
 - lib/rhook.rb
 - rhook.gemspec
+- spec/examples/log_buffer_example_spec.rb
 - spec/rhook_minor_spec.rb
 - spec/rhook_spec.rb
 - spec/spec.opts
 - spec/spec_helper.rb
-has_rdoc: true
+has_rdoc: yard
 homepage: http://github.com/kaorukobo/rhook
 licenses: []
 
 post_install_message: 
-rdoc_options: 
-- --charset=UTF-8
+rdoc_options: []
+
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
@@ -68,6 +88,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
       segments: 
       - 0
       version: "0"
@@ -76,6 +97,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
       segments: 
       - 0
       version: "0"
@@ -87,6 +109,8 @@ signing_key:
 specification_version: 3
 summary: Easily drive AOP & hacking existing library with Ruby
 test_files: 
+- examples/log_socket_data.rb
+- spec/examples/log_buffer_example_spec.rb
 - spec/rhook_minor_spec.rb
 - spec/rhook_spec.rb
 - spec/spec_helper.rb

data/.gitignore

@@ -1,21 +0,0 @@
-## MAC OS
-.DS_Store
-
-## TEXTMATE
-*.tmproj
-tmtags
-
-## EMACS
-*~
-\#*
-.\#*
-
-## VIM
-*.swp
-
-## PROJECT::GENERAL
-coverage
-rdoc
-pkg
-
-## PROJECT::SPECIFIC