evalhook 0.1.0

data/AUTHORS

@@ -0,0 +1 @@
+evalhook de tario <rseminara@hotmail.com>

data/CHANGELOG

@@ -0,0 +1,12 @@
+0.1.0	Created RDOC
+		
+		Implemented use examples
+
+		Fixed functionality for shikashi sandbox
+
+		added method hook tree no hook the tree of a ruby method
+
+		implemented hook of global vars assignments
+
+		implemented hook of constant assigment (handle_cdecl)
+

data/README

@@ -0,0 +1,108 @@
+= evalhook - Alternate eval which hook all methods (and more) in the evaluated code
+
+== Installation
+
+=== Gem installation
+
+Run in the terminal:
+
+sudo gem install evalhook
+
+OR
+
+* Download the last version of the gem from http://github.com/tario/evalhook/downloads
+* Install the gem with the following;
+
+sudo gem install evalhook-X.X.X.gem.
+
+== Documentation
+
+Full API documentation can be found on:
+http://tario.github.com/evalhook/doc/
+
+== Usage
+
+This examples and more can be found in examples directory
+
+=== Basic Example
+
+Hook of method calls
+
+	require "rubygems"
+	require "evalhook"
+
+	class Hook < EvalHook::HookHandler
+		def handle_method(klass, recv, method_name)
+			print "called #{klass}##{method_name} over #{recv}\n"
+			nil
+		end
+	end
+
+	h = Hook.new
+	h.evalhook('print "hello world\n"')
+
+=== Basic Example 2
+
+Hook of global variables and constants
+
+	require "rubygems"
+	require "evalhook"
+
+	class Hook < EvalHook::HookHandler
+		# global variable assignment/creation
+		def handle_gasgn( global_name, new_value)
+			print "assignment of #{global_name} = #{new_value}\n"
+			nil
+		end
+
+		# constant assignment/creation
+		def handle_cdecl( container, const_name, new_value)
+			print "assignment of #{container}::#{const_name} = #{new_value}\n"
+			nil
+		end
+	end
+
+	h = Hook.new
+	h.evalhook('
+	$a = 4
+	A = 4', binding)
+
+
+=== Basic Example 3
+
+Redirect of method calls
+
+	require "rubygems"
+	require "evalhook"
+
+	class Hook < EvalHook::HookHandler
+		
+		include RedirectHelper
+		
+		def handle_method(klass, recv, method_name)
+			print "called #{klass}##{method_name} over #{recv}\n"
+			
+			if method_name == :print
+				# change the method_name to alternative_print
+				Redirect.new(klass, recv, "alternative_print")
+			else
+				nil # do nothing
+			end
+			
+		end
+	end
+
+	module Kernel
+		def alternative_print(*args)
+			print "alternative ", *args
+		end
+	end
+
+	h = Hook.new
+	h.evalhook('print "hello world\n"')
+
+	
+== Copying
+
+Copyright (c) 2010 Dario Seminara, released under the GPL License (see LICENSE)
+	

data/Rakefile

@@ -0,0 +1,48 @@
+require 'rubygems'
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+require 'rake/gempackagetask'
+
+spec = Gem::Specification.new do |s|
+  s.name = 'evalhook'
+  s.version = '0.1.0'
+  s.author = 'Dario Seminara'
+  s.email = 'robertodarioseminara@gmail.com'
+  s.platform = Gem::Platform::RUBY
+  s.summary = 'Alternate eval which hook all methods executed in the evaluated code'
+  s.homepage = "http://github.com/tario/evalhook"
+  s.has_rdoc = true
+  s.extra_rdoc_files = [ 'README' ]
+  s.rdoc_options << '--main' << 'README'
+  s.extensions = FileList["ext/**/extconf.rb"].to_a
+  s.files = Dir.glob("{examples,lib,test}/**/*.rb") + Dir.glob("ext/**/*.c") + Dir.glob("ext/**/*.h") + Dir.glob("ext/**/extconf.rb") +
+    [ 'AUTHORS', 'CHANGELOG', 'README', 'Rakefile', 'TODO' ]
+end
+
+desc 'Run tests'
+task :default => [ :test ]
+
+Rake::TestTask.new('test') do |t|
+  t.libs << 'test'
+  t.pattern = '{test}/**/test_*.rb'
+  t.verbose = true
+end
+
+desc 'Generate RDoc'
+Rake::RDocTask.new :rdoc do |rd|
+  rd.rdoc_dir = 'doc'
+  rd.rdoc_files.add 'lib', 'ext', 'README'
+  rd.main = 'README'
+end
+
+desc 'Build Gem'
+Rake::GemPackageTask.new spec do |pkg|
+  pkg.need_tar = true
+end
+
+desc 'Clean up'
+task :clean => [ :clobber_rdoc, :clobber_package ]
+
+desc 'Clean up'
+task :clobber => [ :clean ]

data/TODO

@@ -0,0 +1,2 @@
+* Using of parainterpretation in place of in-memory node tree changing
+* Ruby 1.9 compatibility

data/examples/example1.rb

@@ -0,0 +1,12 @@
+require "rubygems"
+require "evalhook"
+
+class Hook < EvalHook::HookHandler
+	def handle_method(klass, recv, method_name)
+		print "called #{klass}##{method_name} over #{recv}\n"
+		nil
+	end
+end
+
+h = Hook.new
+h.evalhook('print "hello world\n"')

data/examples/example2.rb

@@ -0,0 +1,21 @@
+require "rubygems"
+require "evalhook"
+
+class Hook < EvalHook::HookHandler
+	# global variable assignment/creation
+	def handle_gasgn( global_name, new_value)
+		print "assignment of #{global_name} = #{new_value}\n"
+		nil
+	end
+
+	# constant assignment/creation
+	def handle_cdecl( container, const_name, new_value)
+		print "assignment of #{container}::#{const_name} = #{new_value}\n"
+		nil
+	end
+end
+
+h = Hook.new
+h.evalhook('
+$a = 4
+A = 4', binding)

data/examples/example3.rb

@@ -0,0 +1,28 @@
+require "rubygems"
+require "evalhook"
+
+class Hook < EvalHook::HookHandler
+	
+	include RedirectHelper
+	
+	def handle_method(klass, recv, method_name)
+		print "called #{klass}##{method_name} over #{recv}\n"
+		
+		if method_name == :print
+			# change the method_name to alternative_print
+			Redirect.new(klass, recv, "alternative_print")
+		else
+			nil # do nothing
+		end
+		
+	end
+end
+
+module Kernel
+	def alternative_print(*args)
+		print "alternative ", *args
+	end
+end
+
+h = Hook.new
+h.evalhook('print "hello world\n"')

data/ext/evalhook_base/evalhook_base.c

@@ -0,0 +1,679 @@
+/*
+
+This file is part of the evalhook project, http://github.com/tario/evalhook
+
+Copyright (c) 2010 Roberto Dario Seminara <robertodarioseminara@gmail.com>
+
+evalhook is free software: you can redistribute it and/or modify
+it under the terms of the gnu general public license as published by
+the free software foundation, either version 3 of the license, or
+(at your option) any later version.
+
+evalhook is distributed in the hope that it will be useful,
+but without any warranty; without even the implied warranty of
+merchantability or fitness for a particular purpose.  see the
+gnu general public license for more details.
+
+you should have received a copy of the gnu general public license
+along with evalhook.  if not, see <http://www.gnu.org/licenses/>.
+
+*/
+
+#include <ruby.h>
+#include <env.h>
+#include <node.h>
+
+VALUE m_EvalHook ;
+VALUE c_HookHandler;
+
+#define nd_3rd   u3.node
+
+ID method_call;
+ID method_hooked_method;
+ID method_local_hooked_method;
+ID method_private_hooked_method;
+ID method_public_hooked_method;
+ID method_protected_hooked_method;
+ID method_public, method_private, method_protected;
+
+ID method_set_hook_handler;
+
+struct BLOCK {
+    NODE *var;
+    NODE *body;
+    VALUE self;
+    struct FRAME frame;
+    struct SCOPE *scope;
+    VALUE klass;
+    NODE *cref;
+    int iter;
+    int vmode;
+    int flags;
+    int uniq;
+    struct RVarmap *dyna_vars;
+    VALUE orig_thread;
+    VALUE wrapper;
+    VALUE block_obj;
+    struct BLOCK *outer;
+    struct BLOCK *prev;
+};
+
+struct METHOD {
+    VALUE klass, rklass;
+    VALUE recv;
+    ID id, oid;
+    int safe_level;
+    NODE *body;
+};
+
+
+void process_node(NODE* node, VALUE handler);
+
+void patch_local_call_node(NODE* node, VALUE handler) {
+	NODE* args1 = NEW_LIST(NEW_LIT(ID2SYM(node->nd_mid)));
+	NODE* args2 = NEW_LIST(NEW_LIT(handler));
+
+	node->nd_recv = NEW_CALL(NEW_SELF(), method_local_hooked_method, args1);
+	node->nd_recv = NEW_CALL(node->nd_recv, method_set_hook_handler, args2);
+	node->nd_mid = method_call;
+
+	nd_set_type(node, NODE_CALL);
+}
+
+void patch_call_node(NODE* node, VALUE handler) {
+	NODE* args1 = NEW_LIST(NEW_LIT(ID2SYM(node->nd_mid)));
+	NODE* args2 = NEW_LIST(NEW_LIT(handler));
+
+	node->nd_recv = NEW_CALL(node->nd_recv, method_hooked_method, args1);
+	node->nd_recv = NEW_CALL(node->nd_recv, method_set_hook_handler, args2);
+
+	node->nd_mid = method_call;
+}
+
+struct global_entry {
+    struct global_variable *var;
+    ID id;
+};
+
+void process_individual_node(NODE* node, VALUE handler) {
+	ID id = node->nd_mid;
+
+	switch (nd_type(node)) {
+		case NODE_COLON3: {
+			rb_raise(rb_eSecurityError, "Forbidden node type colon3 (reference to global namespace)");
+		}
+/*		case NODE_LASGN:
+		case NODE_IASGN:
+		case NODE_DASGN:
+		case NODE_CVASGN:
+		case NODE_CVDECL:*/
+		case NODE_GASGN: {
+			NODE* args1 = NEW_LIST(NEW_LIT(ID2SYM(node->nd_entry->id)));
+			NODE* args2 = NEW_LIST(node->nd_value);
+
+			node->nd_recv = NEW_CALL(NEW_LIT(handler), rb_intern("hooked_gasgn"), args1);
+			node->nd_mid = rb_intern("set_value");
+			node->nd_args = args2;
+
+			nd_set_type(node, NODE_CALL);
+			break;
+		}
+		case NODE_CDECL: {
+
+			NODE* else_node = node->nd_else;
+			NODE* head_node = node->nd_head;
+			NODE* base_class;
+
+			ID vid;
+
+			if (node->nd_vid == 0) {
+				base_class = else_node;
+				vid = node->nd_else->nd_mid;
+			} else {
+				base_class = NEW_LIT( (ruby_cref->nd_clss));
+				vid = node->nd_vid;
+			}
+
+
+			NODE* args1 = NEW_LIST(base_class);
+			NODE* args2 = NEW_LIST(NEW_LIT(ID2SYM(vid)));
+			NODE* args3 = NEW_LIST(node->nd_value);
+
+			node->nd_recv = NEW_CALL(NEW_LIT(handler), rb_intern("hooked_cdecl"), args1);
+			node->nd_recv = NEW_CALL(node->nd_recv, rb_intern("set_id"), args2);
+			node->nd_mid = rb_intern("set_value");
+			node->nd_args = args3;
+
+			nd_set_type(node, NODE_CALL);
+			break;
+		}
+
+
+		case NODE_SUPER:
+		case NODE_ZSUPER: {
+			node->nd_mid = rb_intern("hooked_super");
+			node->nd_recv = NEW_LIT(handler);
+			nd_set_type(node, NODE_CALL);
+			break;
+		}
+		case NODE_FCALL: {
+			if (id == method_public) break;
+			if (id == method_private) break;
+			if (id == method_protected) break;
+
+			patch_local_call_node(node, handler);
+			break;
+		}
+
+		case NODE_CALL: {
+			patch_call_node(node, handler);
+			break;
+
+		}
+		case NODE_VCALL: {
+			if (id == method_public) break;
+			if (id == method_private) break;
+			if (id == method_protected) break;
+
+			patch_local_call_node(node, handler);
+
+			break;
+		}
+	}
+}
+
+void process_recursive_node(NODE* node, VALUE handler ) {
+
+  switch (nd_type(node)) {
+
+    case NODE_BLOCK:
+      {
+        while (node) {
+          process_node(node->nd_head, handler);
+          node = node->nd_next;
+        }
+      }
+      break;
+
+    case NODE_FBODY:
+    case NODE_DEFINED:
+    case NODE_COLON2:
+      process_node(node->nd_head, handler);
+      break;
+
+    case NODE_MATCH2:
+    case NODE_MATCH3:
+      process_node(node->nd_recv, handler);
+      process_node(node->nd_value, handler);
+      break;
+
+    case NODE_BEGIN:
+    case NODE_OPT_N:
+    case NODE_NOT:
+      process_node(node->nd_body, handler);
+      break;
+
+    case NODE_IF:
+      process_node(node->nd_cond, handler);
+      if (node->nd_body) {
+	      process_node(node->nd_body, handler);
+      }
+      if (node->nd_else) {
+	      process_node(node->nd_else, handler);
+      }
+      break;
+
+  case NODE_CASE:
+    if (node->nd_head != NULL) {
+      process_node(node->nd_head, handler);
+    }
+    node = node->nd_body;
+    while (node) {
+      process_node(node, handler);
+      if (nd_type(node) == NODE_WHEN) {                 /* when */
+        node = node->nd_next;
+      } else {
+        break;                                          /* else */
+      }
+    }
+    break;
+
+  case NODE_WHEN:
+    process_node(node->nd_head, handler);
+    if (node->nd_body) {
+      process_node(node->nd_body, handler);
+    }
+    break;
+
+  case NODE_WHILE:
+  case NODE_UNTIL:
+    process_node(node->nd_cond, handler);
+    if (node->nd_body) {
+      process_node(node->nd_body, handler);
+    }
+    break;
+
+  case NODE_BLOCK_PASS:
+    process_node(node->nd_body, handler);
+    process_node(node->nd_iter, handler);
+    break;
+
+  case NODE_ITER:
+  case NODE_FOR:
+    process_node(node->nd_iter, handler);
+    if (node->nd_var != (NODE *)1
+        && node->nd_var != (NODE *)2
+        && node->nd_var != NULL) {
+	    process_node(node->nd_var, handler);
+    }
+    process_node(node->nd_body, handler);
+    break;
+
+  case NODE_BREAK:
+  case NODE_NEXT:
+    if (node->nd_stts)
+	    process_node(node->nd_stts, handler);
+
+    break;
+
+  case NODE_YIELD:
+    if (node->nd_stts)
+      process_node(node->nd_stts, handler);
+
+    break;
+
+  case NODE_RESCUE:
+    process_node(node->nd_1st, handler);
+    process_node(node->nd_2nd, handler);
+    process_node(node->nd_3rd, handler);
+    break;
+
+  /*
+  // rescue body:
+  // begin stmt rescue exception => var; stmt; [rescue e2 => v2; s2;]* end
+  // stmt rescue stmt
+  // a = b rescue c
+  */
+
+  case NODE_RESBODY:
+      if (node->nd_3rd) {
+        process_node(node->nd_3rd, handler);
+      }
+      process_node(node->nd_2nd, handler);
+      process_node(node->nd_1st, handler);
+    break;
+
+  case NODE_ENSURE:
+    process_node(node->nd_head, handler);
+    if (node->nd_ensr) {
+    process_node(node->nd_ensr, handler);
+    }
+    break;
+
+  case NODE_AND:
+  case NODE_OR:
+      process_node(node->nd_1st, handler);
+      process_node(node->nd_2nd, handler);
+    break;
+
+  case NODE_FLIP2:
+  case NODE_FLIP3:
+    process_node(node->nd_beg, handler);
+    process_node(node->nd_end, handler);
+    break;
+
+  case NODE_DOT2:
+  case NODE_DOT3:
+    process_node(node->nd_beg, handler);
+    process_node(node->nd_end, handler);
+    break;
+
+  case NODE_RETURN:
+    if (node->nd_stts)
+      process_node(node->nd_stts, handler);
+    break;
+
+  case NODE_ARGSCAT:
+  case NODE_ARGSPUSH:
+    process_node(node->nd_head, handler);
+    process_node(node->nd_body, handler);
+    break;
+
+  case NODE_CALL:
+  case NODE_FCALL:
+  case NODE_VCALL:
+    if (nd_type(node) != NODE_FCALL) {
+    	if (node->nd_recv) process_node(node->nd_recv, handler);
+	 }
+     if (node->nd_args || nd_type(node) != NODE_FCALL) {
+      	if (node->nd_args) process_node(node->nd_args, handler);
+     }
+    break;
+
+  case NODE_SUPER:
+    process_node(node->nd_args, handler);
+    break;
+
+  case NODE_BMETHOD:
+    {
+      struct BLOCK *data;
+      Data_Get_Struct(node->nd_cval, struct BLOCK, data);
+
+      if (data->var == 0 || data->var == (NODE *)1 || data->var == (NODE *)2) {
+      } else {
+	      process_node(data->var, handler);
+      }
+      process_node(data->body, handler);
+    }
+    break;
+
+#if RUBY_VERSION_CODE < 190
+  case NODE_DMETHOD:
+    {
+      struct METHOD *data;
+      Data_Get_Struct(node->nd_cval, struct METHOD, data);
+      process_node(data->body, handler);
+
+      break;
+    }
+#endif
+
+  case NODE_METHOD:
+    // You should not ever get here. parse_tree_for_meth passes nd_body
+    process_node(node->nd_body, handler);
+    break;
+
+  case NODE_SCOPE:
+    process_node(node->nd_next, handler);
+    break;
+
+  case NODE_OP_ASGN1:
+    process_node(node->nd_recv, handler);
+#if RUBY_VERSION_CODE < 185
+    process_node(node->nd_args->nd_next, handler);
+#else
+    process_node(node->nd_args->nd_2nd, handler);
+#endif
+    process_node(node->nd_args->nd_head, handler);
+    break;
+
+  case NODE_OP_ASGN2:
+    process_node(node->nd_recv, handler);
+    process_node(node->nd_value, handler);
+    break;
+
+  case NODE_OP_ASGN_AND:
+  case NODE_OP_ASGN_OR:
+    process_node(node->nd_head, handler);
+    process_node(node->nd_value, handler);
+    break;
+
+  case NODE_MASGN:
+    if (node->nd_head) {
+    process_node(node->nd_head, handler);
+    }
+    if (node->nd_args) {
+      if (node->nd_args != (NODE *)-1) {
+	    process_node(node->nd_args, handler);
+      }
+    }
+    if (node->nd_value) {
+	    process_node(node->nd_value, handler);
+    }
+    break;
+
+  case NODE_LASGN:
+  case NODE_IASGN:
+  case NODE_DASGN:
+  case NODE_CVASGN:
+  case NODE_CVDECL:
+  case NODE_GASGN:
+    process_node(node->nd_value, handler);
+    break;
+
+  case NODE_CDECL:
+    if (node->nd_vid) {
+    } else {
+      process_node(node->nd_else, handler);
+    }
+    process_node(node->nd_value, handler);
+    break;
+
+  case NODE_DASGN_CURR:
+    if (node->nd_value) {
+      process_node(node->nd_value, handler);
+    }
+    break;
+
+  case NODE_ALIAS:            /* u1 u2 (alias :blah :blah2) */
+#if RUBY_VERSION_CODE < 185
+#else
+    process_node(node->nd_1st, handler);
+    process_node(node->nd_2nd, handler);
+#endif
+    break;
+
+  case NODE_UNDEF:            /* u2    (undef name, ...) */
+#if RUBY_VERSION_CODE < 185
+#else
+    process_node(node->nd_value, handler);
+#endif
+    break;
+
+  case NODE_HASH:
+    {
+      NODE *list;
+
+      list = node->nd_head;
+      while (list) {
+	    process_node(list->nd_head, handler);
+        list = list->nd_next;
+      }
+    }
+    break;
+
+  case NODE_ARRAY:
+      while (node) {
+	    process_node(node->nd_head, handler);
+        node = node->nd_next;
+      }
+    break;
+
+  case NODE_DSTR:
+  case NODE_DSYM:
+  case NODE_DXSTR:
+  case NODE_DREGX:
+  case NODE_DREGX_ONCE:
+    {
+      NODE *list = node->nd_next;
+      while (list) {
+        if (list->nd_head) {
+		  process_node(list->nd_head, handler);
+        }
+        list = list->nd_next;
+      }
+    }
+    break;
+
+  case NODE_DEFN:
+  case NODE_DEFS:
+    if (node->nd_defn) {
+      if (nd_type(node) == NODE_DEFS)
+	    process_node(node->nd_recv, handler);
+
+      process_node(node->nd_defn, handler);
+    }
+    break;
+
+  case NODE_CLASS:
+  case NODE_MODULE:
+    if (nd_type(node->nd_cpath) == NODE_COLON2 && ! node->nd_cpath->nd_vid) {
+    } else {
+      process_node(node->nd_cpath, handler);
+    }
+
+    if (nd_type(node) == NODE_CLASS) {
+      if (node->nd_super) {
+        process_node(node->nd_super, handler);
+      }
+    }
+    process_node(node->nd_body, handler);
+    break;
+
+  case NODE_SCLASS:
+    process_node(node->nd_recv, handler);
+    process_node(node->nd_body, handler);
+    break;
+
+  case NODE_ARGS: {
+    NODE *optnode;
+    optnode = node->nd_opt;
+    if (optnode) {
+	  process_node(node->nd_opt, handler);
+    }
+  }  break;
+
+  case NODE_NEWLINE:
+    process_node(node->nd_next, handler);
+    break;
+
+  case NODE_SPLAT:
+  case NODE_TO_ARY:
+  case NODE_SVALUE:             /* a = b, c */
+    process_node(node->nd_head, handler);
+    break;
+
+  case NODE_ATTRASGN:           /* literal.meth = y u1 u2 u3 */
+    /* node id node */
+    if (node->nd_1st == RNODE(1)) {
+//      add_to_parse_tree(self, current, NEW_SELF(), locals);
+    } else {
+        process_node(node->nd_1st, handler);
+    }
+    process_node(node->nd_3rd, handler);
+    break;
+
+  case NODE_EVSTR:
+    process_node(node->nd_2nd, handler);
+    break;
+
+
+#if RUBY_VERSION_CODE >= 190
+  case NODE_ERRINFO:
+  case NODE_VALUES:
+  case NODE_PRELUDE:
+  case NODE_LAMBDA:
+    puts("no worky in 1.9 yet");
+    break;
+#endif
+
+  /* Nodes we found but have yet to decypher */
+  /* I think these are all runtime only... not positive but... */
+  case NODE_MEMO:               /* enum.c zip */
+  case NODE_CREF:
+  /* #defines: */
+  /* case NODE_LMASK: */
+  /* case NODE_LSHIFT: */
+  default:
+    break;
+  }
+}
+
+void process_node(NODE* node, VALUE handler) {
+	if (node) {
+	process_recursive_node(node, handler);
+	process_individual_node(node, handler);
+	}
+}
+
+VALUE hook_method_tree(VALUE self, VALUE rb_method) {
+
+	struct METHOD* method;
+	Data_Get_Struct(rb_method,struct METHOD,method);
+
+	NODE* node = method->body->nd_defn;
+	process_node(node, self);
+
+	return Qnil;
+}
+
+
+VALUE hook_block(VALUE self, VALUE handler) {
+	process_node(ruby_frame->node->nd_recv, handler);
+}
+
+VALUE caller_method(VALUE self, VALUE rblevel) {
+	int level = FIX2INT(rblevel);
+
+	struct FRAME* frame = ruby_frame;
+	while(level--) frame = frame->prev;
+
+	return ID2SYM(frame->orig_func);
+}
+
+VALUE caller_class(VALUE self, VALUE rblevel) {
+	int level = FIX2INT(rblevel);
+
+	struct FRAME* frame = ruby_frame;
+	while(level--) frame = frame->prev;
+
+	return frame->last_class;
+}
+
+VALUE caller_obj(VALUE self, VALUE rblevel) {
+	int level = FIX2INT(rblevel);
+
+	struct FRAME* frame = ruby_frame;
+	while(level--) frame = frame->prev;
+
+	return frame->self;
+}
+
+
+extern void Init_evalhook_base() {
+	m_EvalHook = rb_define_module("EvalHook");
+
+/*
+Class to create hook instances for specific handling of method calls and/or const and global assignment
+
+=== Example:
+
+Hook of method calls
+
+	require "rubygems"
+	require "evalhook"
+
+	class Hook < EvalHook::HookHandler
+		def handle_method(klass, recv, method_name)
+			print "called #{klass}##{method_name} over #{recv}\n"
+			nil
+		end
+	end
+
+	h = Hook.new
+	h.evalhook('print "hello world\n"')
+
+
+
+
+See README for more examples
+
+*/
+	c_HookHandler = rb_define_class_under(m_EvalHook, "HookHandler", rb_cObject);
+
+	rb_define_singleton_method(m_EvalHook, "hook_block", hook_block, 1);
+
+	rb_define_method(c_HookHandler, "hook_method_tree", hook_method_tree, 1);
+
+	rb_define_method(c_HookHandler, "caller_method", caller_method, 1);
+	rb_define_method(c_HookHandler, "caller_class", caller_class, 1);
+	rb_define_method(c_HookHandler, "caller_obj", caller_obj, 1);
+
+	method_local_hooked_method = rb_intern("local_hooked_method");
+	method_hooked_method = rb_intern("hooked_method");
+	method_call = rb_intern("call");
+	method_private = rb_intern("private");
+	method_public = rb_intern("public");
+	method_protected = rb_intern("protected");
+	method_set_hook_handler = rb_intern("set_hook_handler");
+}

data/ext/evalhook_base/extconf.rb

@@ -0,0 +1,7 @@
+require 'mkmf'
+dir_config('evalhook_base')
+CONFIG['CC'] = 'gcc'
+create_makefile('evalhook_base')
+
+
+

data/lib/evalhook/redirect_helper.rb

@@ -0,0 +1,54 @@
+=begin
+
+This file is part of the evalhook project, http://github.com/tario/evalhook
+
+Copyright (c) 2010 Roberto Dario Seminara <robertodarioseminara@gmail.com>
+
+evalhook is free software: you can redistribute it and/or modify
+it under the terms of the gnu general public license as published by
+the free software foundation, either version 3 of the license, or
+(at your option) any later version.
+
+evalhook is distributed in the hope that it will be useful,
+but without any warranty; without even the implied warranty of
+merchantability or fitness for a particular purpose.  see the
+gnu general public license for more details.
+
+you should have received a copy of the gnu general public license
+along with evalhook.  if not, see <http://www.gnu.org/licenses/>.
+
+=end
+module RedirectHelper
+  module MethodRedirect
+  end
+
+#
+#Internal class used for return method redirection messages
+#Example:
+# ...
+# class X
+#   def foo
+#   end
+# end
+# def handle_method
+#   return RedirectHelper::Redirect.new(X, X.new, :foo)
+# end
+
+  class Redirect
+    include MethodRedirect
+
+    attr_reader :klass
+    attr_reader :recv
+
+    def method_name
+      @method
+    end
+
+    def initialize(klass, recv, m, unhook = nil)
+      @klass = klass
+      @recv = recv
+      @method = m
+    end
+  end
+
+end

data/lib/evalhook.rb

@@ -0,0 +1,219 @@
+=begin
+
+This file is part of the evalhook project, http://github.com/tario/evalhook
+
+Copyright (c) 2010 Roberto Dario Seminara <robertodarioseminara@gmail.com>
+
+evalhook is free software: you can redistribute it and/or modify
+it under the terms of the gnu general public license as published by
+the free software foundation, either version 3 of the license, or
+(at your option) any later version.
+
+evalhook is distributed in the hope that it will be useful,
+but without any warranty; without even the implied warranty of
+merchantability or fitness for a particular purpose.  see the
+gnu general public license for more details.
+
+you should have received a copy of the gnu general public license
+along with evalhook.  if not, see <http://www.gnu.org/licenses/>.
+
+=end
+require "evalhook"
+require "evalhook_base"
+require "evalhook/redirect_helper"
+
+
+class Object
+  def local_hooked_method(mname)
+    EvalHook::HookedMethod.new(self,mname,true)
+  end
+  def hooked_method(mname)
+    EvalHook::HookedMethod.new(self,mname,false)
+  end
+end
+
+module EvalHook
+
+  # used internally
+  class HookedMethod
+
+    def initialize(recv, m,localcall)
+      @recv = recv
+      @m = m
+      @localcall = localcall
+    end
+
+    # used internally
+    def set_hook_handler(method_handler)
+      @method_handler = method_handler
+      self
+    end
+
+    # used internally
+    def set_class(klass)
+      @klass = klass
+      self
+    end
+
+    # used internally
+    def call(*args)
+      method_handler = @method_handler
+      ret = nil
+
+      klass = @klass || @recv.method(@m).owner
+      method_name = @m
+      recv = @recv
+
+      if method_handler
+      ret = method_handler.handle_method(klass, recv, method_name )
+      end
+
+      if ret.kind_of? RedirectHelper::MethodRedirect
+        klass = ret.klass
+        method_name = ret.method_name
+        recv = ret.recv
+      end
+
+      if block_given?
+        klass.instance_method(method_name).bind(recv).call(*args) do |*x|
+          yield(*x)
+        end
+      else
+        klass.instance_method(method_name).bind(recv).call(*args)
+      end
+    end
+  end
+
+  # used internally
+  class FakeEvalHook
+    def self.hook_block(*args)
+    end
+  end
+
+  class HookHandler
+
+    # used internally
+    class HookCdecl
+      def initialize(klass, hook_handler)
+        @klass = klass
+        @hook_handler = hook_handler
+      end
+
+      def set_id(const_id)
+        @const_id = const_id
+        self
+      end
+
+      def set_value(value)
+        klass = @klass
+        const_id = @const_id
+
+        ret = @hook_handler.handle_cdecl( @klass, @const_id, value )
+
+        if ret then
+          klass = ret.klass
+          const_id = ret.const_id
+          value = ret.value
+        end
+
+        klass.const_set(const_id, value)
+      end
+    end
+
+    # used internally
+    class HookGasgn
+      def initialize(global_id, hook_handler)
+        @global_id = global_id
+        @hook_handler = hook_handler
+      end
+
+      def set_value(value)
+        global_id = @global_id
+
+        ret = @hook_handler.handle_gasgn(@global_id, value)
+
+        if ret then
+          global_id = ret.global_id
+          value = ret.value
+        end
+
+        eval("#{global_id} = value")
+      end
+    end
+
+    # used internally
+    def hooked_cdecl(context)
+      HookCdecl.new(context,self)
+    end
+
+    # used internally
+    def hooked_gasgn(global_id)
+      HookGasgn.new(global_id,self)
+    end
+
+    # Overwrite to handle the assignment/creation of global variables. By default do nothing but assign the variable. See examples
+    def handle_gasgn(*args)
+      nil
+    end
+
+    # Overwrite to handle the assignment/creation of constants. By default do nothing but assign the variable. See examples
+    def handle_cdecl(*args)
+      nil
+    end
+
+    # Overwrite to handle the method calls. By default do nothing and the methods are called normally
+    def handle_method(klass,recv,method_name)
+      nil
+    end
+
+    def hooked_super(*args)
+      hm = caller_obj(2).hooked_method(caller_method(2))
+      hm.set_class(caller_class(2).superclass)
+      hm.set_hook_handler(self)
+
+      if block_given?
+        hm.call(*args) do |*x|
+          yield(*x)
+        end
+      else
+        hm.call(*args)
+      end
+    end
+
+    def evalhook(*args)
+
+      EvalHook.method_handler = self
+
+      args[0] = "
+        retvalue = nil
+        EvalHook.double_run do |run|
+          ( if (run)
+            retvalue = begin
+              #{args[0]}
+            end
+            EvalHook::FakeEvalHook
+          else
+            EvalHook
+          end ).hook_block(ObjectSpace._id2ref(#{object_id}))
+        end
+        retvalue
+       "
+      eval(*args)
+
+    end
+  end
+
+	module ModuleMethods
+
+   attr_accessor :method_handler
+
+   def double_run
+     yield(false)
+     yield(true)
+   end
+	end
+
+  class << self
+    include ModuleMethods
+  end
+end

metadata

@@ -0,0 +1,79 @@
+--- !ruby/object:Gem::Specification 
+name: evalhook
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Dario Seminara
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-10-30 00:00:00 -03:00
+default_executable: 
+dependencies: []
+
+description: 
+email: robertodarioseminara@gmail.com
+executables: []
+
+extensions: 
+- ext/evalhook_base/extconf.rb
+extra_rdoc_files: 
+- README
+files: 
+- examples/example1.rb
+- examples/example3.rb
+- examples/example2.rb
+- lib/evalhook/redirect_helper.rb
+- lib/evalhook.rb
+- ext/evalhook_base/evalhook_base.c
+- ext/evalhook_base/extconf.rb
+- AUTHORS
+- CHANGELOG
+- README
+- Rakefile
+- TODO
+has_rdoc: true
+homepage: http://github.com/tario/evalhook
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --main
+- README
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Alternate eval which hook all methods executed in the evaluated code
+test_files: []
+