Christoph Heindl

[Ruby] On Method Hooks in Ruby: any cleaner?

2008-12-10T20:23:50-08:00

Using the ancestor chain + overriding existing to call ancestor is a nice idea. Thanks for sharing your thoughts.

[Ruby] On A hash of arrays (adding to and creating)

2008-12-09T08:35:11-08:00

Here is another idiom (just for completion): the Hash#[]= operation returns the value you've just assigned to it. So you might do the following

@appointments_by_day = {}
day_counter = 1
#runt_objects is an array

while day_counter <= month_days
  entry = @appointments_by_day[day_counter] || @appointments_by_day[day_counter] = []
  entry << runt_object[1]
  day_counter += 1
end

[Ruby] On Method Hooks in Ruby: any cleaner?

2008-12-09T07:44:10-08:00

raggi,

thanks for your input!

I browsed the changes for #alias_method in ruby 1.9 (http://eigenclass.org/hiki.rb?Changes+in+Ruby+1.9) but could not find any hints on #alias_method requiring symbols. http://www.ruby-doc.org/core-1.9/index.html misses that part too.

Guess I have to install it :)

I agree that hooking method may produce an environment that is hard to maintain, but sometimes (maybe rarely) hooking is just what gets you the job done quickly and does not cluster your code see contrived example below, don't you think?

Best regards,
christoph

require 'logger'
require 'util/following'

$Log = Logger.new(STDOUT)
$Log.level = Logger::DEBUG

class Window
  attr_accessor :text
  attr_reader :renderer

  if $Log.level <= Logger::DEBUG
    include FollowingHook
    following :text=, :text, :renderer do |sender, args|
      $Log.debug("#{sender} called with arguments #{args[:args].join(',')}")
    end
  end
end

[Ruby] Method Hooks in Ruby: any cleaner?

2008-12-08T09:31:43-08:00

The following module provides method hooks (code that is called after a method has been invoked) for specified methods. Is that readable of general use for you? For more examples and unit tests please follow the discussion at http://cheind.blogspot.com/2008/12/method-hooks-in-ruby.html . Criticism welcome! Thanks!

#
# Project:: Ruby-Snippets
# 
# Author:: Christoph Heindl  (mailto:christoph.heindl@gmail.com)
# Homepage:: http://cheind.blogspot.com
#
# == Overview
# 
# Implements <tt>FollowingHook#following</tt>. A
# utility to hook into instance methods and execute
# custom code after hooked methods are called.
#
# See discussion at
# http://cheind.blogspot.com/2008/12/method-hooks-in-ruby.html
#


# Contains methods to hook method calls
module FollowingHook
  
  module ClassMethods
    
    private
    
    # Hook the provided instance methods so that the block 
    # is executed directly after the specified methods have been invoked.
    #
    # There can only be one hook for a single instance method. Further attempts
    # to hook already hooked methods will be silently ignored.
    #
    # +syms+ is list of method symbols or stringified names to hook on
    # +block+ is the block to execute after hooked method has been invoked.
    # Block will receive two arguments: the receiver of the method and an argument hash
    # which contains the invoked method name <tt>:method</tt>, the arguments passed to
    # the method <tt>:args</tt> and the return value of the method <tt>:return</tt>.
    #
    #   class Object
    #     include FollowingHook
    #     following :system do |receiver, args|
    #       p "#{args[:method]} called with arguments #{args[:args].join(",")}"
    #       p "return value was #{args[:return]}"
    #     end
    #   end
    #
    #   system('ruby --version')
    #   # => ruby 1.8.6 (2008-08-11 patchlevel 287) [i386-mswin32]
    #   # => "system called with arguments ruby --version"
    #   # => "return value was true"
    #   # => true
    #
    def following(*syms, &block)
      syms.each do |sym| # For each symbol
        str_id = "__#{sym}__hooked__"
        unless private_instance_methods.include?(str_id)
          alias_method str_id, sym        # Backup original method
          private str_id                  # Make backup private
          define_method sym do |*args|    # Replace method
            ret = __send__ str_id, *args  # Invoke backup
            block.call(self,              # Invoke hook
              :method => sym, 
              :args => args,
              :return => ret
            )
            ret # Forward return value of method
          end
        end
      end
    end
  end
  
  # On inclusion, we extend the receiver by the defined class-methods
  # This is an ruby idiom for defining class methods within a module.
  def FollowingHook.included(base)
    base.extend(ClassMethods)
  end
end