evalhook 0.3.1 → 0.4.0

data/CHANGELOG

@@ -1,3 +1,15 @@
+0.4.0	Removed evalmimic dependency
+
+		Implemented hooking of super as methods calls
+
+		Added hooking for colon2 namespace access (handle_colon2)
+
+		Added hooking for global variable read acess (handle_gvar)
+
+		Added hooking for constant read access (handle_const)
+		
+		Refactor of AST processing code (using SexpProcessor)
+
 0.3.1	Fixed bug when use reflection on call handler (thanks jembezmamy for the feedback!)
 
 0.3.0	Refactor: removed C extension for hooking and use partialruby instead

data/Rakefile

@@ -6,18 +6,18 @@ require 'rake/gempackagetask'
 
 spec = Gem::Specification.new do |s|
   s.name = 'evalhook'
-  s.version = '0.3.1'
+  s.version = '0.4.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.add_dependency "partialruby", ">= 0.1.0"
+  s.add_dependency "partialruby", ">= 0.2.0"
   s.add_dependency "ruby_parser", ">= 2.0.6"
   s.has_rdoc = true
   s.extra_rdoc_files = [ 'README' ]
   s.rdoc_options << '--main' << 'README'
-  s.files = Dir.glob("{examples,lib,spec}/**/*.rb") + Dir.glob("ext/**/*.c") + Dir.glob("ext/**/*.h") + Dir.glob("ext/**/extconf.rb") +
+  s.files = Dir.glob("{examples,lib,spec}/**/*.rb") +
     [ 'LICENSE', 'AUTHORS', 'CHANGELOG', 'README', 'Rakefile', 'TODO' ]
 end
 
@@ -33,7 +33,7 @@ end
 desc 'Generate RDoc'
 Rake::RDocTask.new :rdoc do |rd|
   rd.rdoc_dir = 'doc'
-  rd.rdoc_files.add 'lib', 'ext', 'README'
+  rd.rdoc_files.add 'lib', 'README'
   rd.main = 'README'
 end
 

data/lib/evalhook/redirect_helper.rb

@@ -73,6 +73,21 @@ module RedirectHelper
     end
   end
 
+  class Value
+    attr_reader :value
+    def initialize(value)
+      @value = value
+    end
+  end
+
+  def global_value(value)
+    Value.new(value)
+  end
+
+  def const_value(value)
+    Value.new(value)
+  end
+
   def redirect_method(*args)
     Redirect.new(*args)
   end

data/lib/evalhook/tree_processor.rb

@@ -0,0 +1,279 @@
+=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 "ruby_parser"
+require "partialruby"
+require "sexp_processor"
+
+module EvalHook
+
+
+  class TreeProcessor < SexpProcessor
+    def initialize(hook_handler)
+      super()
+      @hook_handler = hook_handler
+      @def_scope = Array.new
+      self.require_empty = false
+    end
+
+    def const_path_emul(code)
+      if code.instance_of? Array
+        if (code.size == 1)
+          s(:const, code[-1].to_sym)
+        else
+          s(:colon2, const_path_emul(code[0..-2]), code[-1].to_sym)
+        end
+      else
+        const_path_emul code.split("::")
+      end
+    end
+
+    def hook_handler_reference
+      # create a global_variable name
+      unless @hh_ref_global_name
+        global_variable_name = "$hook_handler_" + rand(10000000000).to_s
+        eval("#{global_variable_name} = @hook_handler")
+
+        @hh_ref_global_name = global_variable_name.to_sym
+      end
+
+      s(:gvar, @hh_ref_global_name)
+    end
+
+    def process_gasgn(tree)
+
+      args1 = s(:arglist, s(:lit, tree[1]))
+      args2 = s(:arglist, process(tree[2]))
+
+      firstcall = s(:call, hook_handler_reference, :hooked_gasgn, args1)
+
+      s(:call, firstcall, :set_value, args2)
+
+    end
+
+
+    def process_call(tree)
+
+          original_receiver = tree[1]
+
+          receiver = process(original_receiver|| s(:self))
+
+          args1 = s(:arglist, s(:lit, tree[2]), s(:call, nil, :binding, s(:arglist)))
+          args2 = s(:arglist, hook_handler_reference)
+
+          firstcall = nil
+          secondcall = nil
+
+          if original_receiver
+            firstcall = s(:call, receiver, :local_hooked_method, args1)
+            secondcall = s(:call, firstcall, :set_hook_handler, args2)
+          else
+            firstcall = s(:call, receiver, :hooked_method, args1)
+            secondcall = s(:call, firstcall, :set_hook_handler, args2)
+          end
+
+          s(:call, secondcall, :call, process(tree[3]))
+    end
+
+    def process_cdecl(tree)
+
+          const_tree = tree[1]
+          value_tree = tree[2]
+
+          base_class_tree = nil
+          const_id = nil
+
+          unless const_tree.instance_of? Symbol
+            if const_tree[0] == :colon2
+              base_class_tree = const_tree[1]
+              const_id = const_tree[2]
+            elsif const_tree[0] == :colon3
+              base_class_tree = s(:lit, Object)
+              const_id = const_tree[1]
+            end
+          else
+            base_class_tree = s(:lit, Object)
+            const_id = const_tree
+          end
+
+          args1 = s(:arglist, base_class_tree)
+          args2 = s(:arglist, s(:lit, const_id))
+          args3 = s(:arglist, process(value_tree))
+
+          firstcall = s(:call, hook_handler_reference, :hooked_cdecl, args1 )
+          secondcall = s(:call, firstcall, :set_id, args2)
+
+          s(:call, secondcall, :set_value, args3)
+    end
+
+    def process_dxstr(tree)
+       dstr_tree = tree.dup
+       dstr_tree[0] = :dstr
+
+       args = s(:arglist, process(dstr_tree) )
+       s(:call, hook_handler_reference, :hooked_xstr, args)
+    end
+
+    def process_xstr(tree)
+      args = s(:arglist, s(:lit, tree[1]) )
+      s(:call, hook_handler_reference, :hooked_xstr, args)
+    end
+
+    def process_module(tree)
+      module_name_tree = tree[1]
+      if module_name_tree.instance_of? Sexp
+        if module_name_tree.first == :colon3
+          module_name_tree = process_colon3(module_name_tree)
+        end
+      end
+
+      class_scope(nil) {
+        s(:module, module_name_tree, process(tree[2]))
+      }
+    end
+
+    def class_scope(class_name)
+      @def_scope.push(class_name)
+      ret = yield
+      @def_scope.pop
+      ret
+    end
+
+    def process_class(tree)
+      class_name_tree = tree[1]
+      if class_name_tree.instance_of? Sexp
+        if class_name_tree.first == :colon3
+          class_name_tree = process_colon3(class_name_tree)
+        end
+      end
+
+      if tree[2]
+        class_scope(tree[1]) do
+          s(:class, class_name_tree, process(tree[2]), process(tree[3]))
+        end
+      else
+        class_scope(tree[1]) do
+          s(:class, class_name_tree, nil, process(tree[3]))
+        end
+      end
+    end
+
+    def process_colon2(tree)
+      name = tree[2].to_s
+      args = s(:arglist, process(tree[1]), s(:str, name))
+      s(:call, hook_handler_reference, :hooked_colon2, args)
+    end
+
+    def process_colon3(tree)
+      if @hook_handler.base_namespace
+        s(:colon2, const_path_emul(@hook_handler.base_namespace.to_s), tree[1])
+      else
+        s(:colon3, tree[1])
+      end
+    end
+
+    def process_gvar(tree)
+      name = tree[1]
+
+      args = s(:arglist, s(:lit, name))
+      s(:call, hook_handler_reference, :hooked_gvar, args)
+    end
+
+    def process_const(tree)
+      name = tree[1].to_s
+      args = s(:arglist, s(:str, name))
+      s(:call, hook_handler_reference, :hooked_const, args)
+    end
+
+    def process_defn(tree)
+      @last_args = tree[2]
+      @last_method_name = tree[1]
+
+      s(tree[0],tree[1],tree[2],process(tree[3]))
+    end
+
+    def superclass_call_tree
+      current_class_call = nil
+
+      def_class = @def_scope.last
+      if def_class.instance_of? Symbol
+        current_class_call = s(:const, def_class)
+        s(:call, current_class_call, :superclass, s(:arglist))
+      elsif def_class.instance_of? Sexp
+        current_class_call = def_class
+        s(:call, current_class_call, :superclass, s(:arglist))
+      elsif def_class.instance_of? String
+        s(:call, s(:self), :class, s(:arglist))
+      else
+        current_class_call = s(:call, nil, :raise, s(:arglist, s(:const, :SecurityError)))
+        s(:call, current_class_call, :superclass, s(:arglist))
+      end
+    end
+
+    def process_super(tree)
+
+          receiver = s(:self)
+
+          args1 = s(:arglist, s(:lit, @last_method_name), s(:call, nil, :binding, s(:arglist)))
+          args2 = s(:arglist, hook_handler_reference)
+
+          firstcall = s(:call, receiver, :local_hooked_method, args1)
+          secondcall = s(:call, firstcall, :set_hook_handler, args2)
+          thirdcall = s(:call,secondcall,:set_class,s(:arglist, superclass_call_tree))
+
+          # pass the args passed to super
+          s(:call, thirdcall, :call, s(:arglist, *tree[1..-1]))
+
+    end
+
+    def process_defs(tree)
+      block_tree = class_scope( "" ) {
+        process(tree[4])
+      }
+      s(:defs, process(tree[1]), tree[2], tree[3], block_tree)
+    end
+
+    def process_zsuper(tree)
+
+          receiver = s(:self)
+
+          args1 = s(:arglist, s(:lit, @last_method_name), s(:call, nil, :binding, s(:arglist)))
+          args2 = s(:arglist, hook_handler_reference)
+
+          firstcall = s(:call, receiver, :local_hooked_method, args1)
+          secondcall = s(:call, firstcall, :set_hook_handler, args2)
+          thirdcall = s(:call,secondcall,:set_class,s(:arglist, superclass_call_tree))
+
+          # pass the args of the current defn
+
+          args = s(:arglist)
+          @last_args[1..-1].each do |arg_sym|
+            if arg_sym.to_s[0] == "*"
+              args << s(:splat, s(:lvar, arg_sym.to_s[1..-1].to_sym))
+            else
+              args << s(:lvar, arg_sym)
+            end
+          end
+
+          s(:call, thirdcall, :call, args)
+    end
+
+end
+end

data/lib/evalhook.rb

@@ -22,7 +22,8 @@ require "partialruby"
 require "evalhook/redirect_helper"
 require "evalhook/multi_hook_handler"
 require "evalhook/hook_handler"
-require "evalhook/hook_context"
+require "evalhook/tree_processor"
+
 begin
 require "evalmimic"
 $evalmimic_defined = true
@@ -182,6 +183,36 @@ module EvalHook
       end
     end
 
+    # used internally
+    def hooked_gvar(global_id)
+      ret = handle_gvar(global_id)
+      if ret
+        ret.value
+      else
+        eval(global_id.to_s)
+      end
+    end
+
+    # used internally
+    def hooked_const(name)
+      ret = handle_const(name)
+      if ret
+        ret.value
+      else
+         Object.const_get(name)
+       end
+    end
+
+    # used internally
+    def hooked_colon2(context,name)
+      ret = handle_colon2(context, name)
+      if ret
+        ret.value
+      else
+         context.const_get(name)
+      end
+    end
+
     # used internally
     def hooked_cdecl(context)
       HookCdecl.new(context,self)
@@ -217,6 +248,20 @@ module EvalHook
       nil
     end
 
+    # Overwrite to handle const read access
+    def handle_const(name)
+      nil
+    end
+
+    def handle_colon2(context,name)
+      nil
+    end
+
+    # Overwrite to handle global variable read access
+    def handle_gvar(global_id)
+      nil
+    end
+
     # used internally
     def hooked_super(*args)
       hm = caller_obj(2).hooked_method(caller_method(2))
@@ -243,7 +288,10 @@ module EvalHook
 
       tree = RubyParser.new.parse code
 
-      context = EvalHook::HookContext.new(self)
+      context = PartialRuby::PureRubyContext.new
+
+      tree = EvalHook::TreeProcessor.new(self).process(tree)
+
       emulationcode = context.emul tree
 
       eval emulationcode, b_, name, line

data/spec/hook_handler/hook_handler_defaults_spec.rb

@@ -23,7 +23,7 @@ describe EvalHook::HookHandler, "hook handler defaults" do
       hook_handler = EvalHook::HookHandler.new
 
       expected = eval(expr)
-      hook_handler.evalhook(expr).should be == expected
+      hook_handler.evalhook(expr, binding).should be == expected
 
     end
   end
@@ -32,14 +32,14 @@ describe EvalHook::HookHandler, "hook handler defaults" do
      hook_handler = EvalHook::HookHandler.new
 
      $global_variable_test = 5
-     hook_handler.evalhook("$global_variable_test").should be == $global_variable_test
+     hook_handler.evalhook("$global_variable_test", binding).should be == $global_variable_test
   end
 
   it "should allow reference to constants" do
      hook_handler = EvalHook::HookHandler.new
 
      CONSTANTTEST = 5
-     hook_handler.evalhook("CONSTANTTEST").should be == CONSTANTTEST
+     hook_handler.evalhook("CONSTANTTEST", binding).should be == CONSTANTTEST
   end
 
   it "should allow reference to local variables" do
@@ -71,7 +71,7 @@ describe EvalHook::HookHandler, "hook handler defaults" do
 
   it "should allow method calls" do
     hook_handler = EvalHook::HookHandler.new
-    hook_handler.evalhook("X.new.foo").should be X.new.foo
+    hook_handler.evalhook("X.new.foo", binding).should be X.new.foo
   end
 
   it "should capture method calls" do
@@ -80,14 +80,14 @@ describe EvalHook::HookHandler, "hook handler defaults" do
     hook_handler.should_receive(:handle_method).with(X.class,X,:new)
     hook_handler.should_receive(:handle_method).with(X,anything(),:foo)
 
-    hook_handler.evalhook("X.new.foo")
+    hook_handler.evalhook("X.new.foo", binding)
   end
 
   it "should capture constant assignment" do
     hook_handler = EvalHook::HookHandler.new
 
     hook_handler.should_receive(:handle_cdecl).with(Object,:TEST_CONSTANT,4)
-    hook_handler.evalhook("TEST_CONSTANT = 4")
+    hook_handler.evalhook("TEST_CONSTANT = 4", binding)
 
   end
 
@@ -95,7 +95,7 @@ describe EvalHook::HookHandler, "hook handler defaults" do
     hook_handler = EvalHook::HookHandler.new
 
     hook_handler.should_receive(:handle_gasgn).with(:$test_global_variable,4)
-    hook_handler.evalhook("$test_global_variable = 4")
+    hook_handler.evalhook("$test_global_variable = 4", binding)
 
   end
 
@@ -103,7 +103,7 @@ describe EvalHook::HookHandler, "hook handler defaults" do
     hook_handler = EvalHook::HookHandler.new
 
     hook_handler.should_receive(:handle_xstr).with("echo test")
-    hook_handler.evalhook("`echo test`")
+    hook_handler.evalhook("`echo test`", binding)
 
   end
 
@@ -111,7 +111,7 @@ describe EvalHook::HookHandler, "hook handler defaults" do
     hook_handler = EvalHook::HookHandler.new
 
     hook_handler.should_receive(:handle_xstr).with("echo test")
-    hook_handler.evalhook("`echo \#{}test`")
+    hook_handler.evalhook("`echo \#{}test`", binding)
 
   end
 
@@ -119,7 +119,7 @@ describe EvalHook::HookHandler, "hook handler defaults" do
     hook_handler = EvalHook::HookHandler.new
 
     hook_handler.should_receive(:handle_xstr).with("echo test")
-    hook_handler.evalhook("%x[echo test]")
+    hook_handler.evalhook("%x[echo test]", binding)
   end
 
 
@@ -139,14 +139,14 @@ describe EvalHook::HookHandler, "hook handler defaults" do
     hook_handler = EvalHook::HookHandler.new
 
     hook_handler.base_namespace = :A
-    hook_handler.evalhook("::B").should be == A::B
+    hook_handler.evalhook("::B", binding).should be == A::B
   end
 
   it "should allow define base_namespace (const)" do
     hook_handler = EvalHook::HookHandler.new
 
     hook_handler.base_namespace = A
-    hook_handler.evalhook("::B").should be == A::B
+    hook_handler.evalhook("::B", binding).should be == A::B
   end
 
   class C1
@@ -170,7 +170,7 @@ describe EvalHook::HookHandler, "hook handler defaults" do
             def foo
               'A1::C1#foo at evalhook'
             end
-        end")
+        end" , binding)
 
     C1.new.foo.should be == "C1#foo" # C1#foo class remains unchanged
     A1::C1.new.foo.should be == "A1::C1#foo at evalhook" # A1::C1#foo changes
@@ -196,7 +196,7 @@ describe EvalHook::HookHandler, "hook handler defaults" do
           end
 
         end
-    ")
+    ", binding)
 
     C2.new.foo.should be == "::C2#foo at evalhook"
   end
@@ -216,15 +216,14 @@ describe EvalHook::HookHandler, "hook handler defaults" do
             def foo
               'A1::A2::C1#foo at evalhook'
             end
-        end")
+        end", binding)
 
     C1.new.foo.should be == "C1#foo" # C1#foo class remains unchanged
     A1::A2::C1.new.foo.should be == "A1::A2::C1#foo at evalhook" # A1::C1#foo changes
   end
 
-  it "should use current binding when not specified" do
-    a = 9
-    EvalHook::HookHandler.new.evalhook("a").should be == 9
+  it "should allow declaring classes with ::" do
+    EvalHook::HookHandler.new.evalhook("class Fixnum::TestClass12345; end", binding)
   end
 
   module TestInheritedClassMethodError
@@ -243,5 +242,187 @@ describe EvalHook::HookHandler, "hook handler defaults" do
     hh.evalhook('TestInheritedClassMethodError::B.foo', binding)
   end
 
+  it "should allow declaring modules with ::" do
+    EvalHook::HookHandler.new.evalhook("module Fixnum::TestModule12345; end", binding)
+  end
+
+  module TestModule12347
+  end
+
+  it "should allow assignment of constants nested on modules" do
+    EvalHook::HookHandler.new.evalhook("TestModule12347::A = 9", binding)
+  end
+
+  class XTEST44
+    def foo(a)
+      a+1
+    end
+  end
+  it "should pass arguments on super" do
+    EvalHook::HookHandler.new.evalhook('
+      class YTEST44 < XTEST44
+        def foo(a)
+          super
+        end
+      end
+      YTEST44.new.foo(9)
+    ', binding).should be == 10
+  end
+
+  it "should pass arguments on super (explicitly)" do
+    EvalHook::HookHandler.new.evalhook('
+      class YTEST45 < XTEST44
+        def foo(a)
+          super(a)
+        end
+      end
+      YTEST45.new.foo(9)
+    ', binding).should be == 10
+  end
+
+  it "should pass arguments on super with three levels" do
+    EvalHook::HookHandler.new.evalhook('
+      class YTEST46 < XTEST44
+        def foo(a)
+          super(a)
+        end
+      end
+
+      class ZTEST46 < YTEST46
+        def foo(a)
+          super(a)
+        end
+      end
+      ZTEST46.new.foo(9)
+    ', binding).should be == 10
+
+  end
+
+  it "should raise SecurityError when use super outside a class" do
+
+    lambda {
+
+    EvalHook::HookHandler.new.evalhook('
+      module MODULETEST48
+        def foo(a)
+          super(a)
+        end
+      end
+
+      class XTEST48 < XTEST44
+        include MODULETEST48
+      end
+      XTEST48.new.foo(9)
+    ', binding)
+
+    }.should raise_error(SecurityError)
+
+  end
+
+  it "should raise SecurityError when use super inside a module nested on class" do
+
+    lambda {
+
+    EvalHook::HookHandler.new.evalhook('
+
+      class CLASSTEST49
+        module MODULETEST49
+          def foo(a)
+            super(a)
+          end
+        end
+      end
+
+      class YTEST49 < XTEST44
+        include CLASSTEST49::MODULETEST49
+      end
+      YTEST49.new.foo(9)
+    ', binding)
+
+    }.should raise_error(SecurityError)
+
+  end
+
+  it "should pass arguments on super with no arguments throught three levels" do
+    EvalHook::HookHandler.new.evalhook('
+      class YTEST50 < XTEST44
+        def foo(a)
+          super
+        end
+      end
+
+      class ZTEST50 < YTEST50
+        def foo(a)
+          super
+        end
+      end
+      ZTEST50.new.foo(9)
+    ', binding).should be == 10
+
+  end
+
+  it "should raise SecurityError when use super with no arguments outside a class" do
+
+    lambda {
+
+    EvalHook::HookHandler.new.evalhook('
+      module MODULETEST51
+        def foo(a)
+          super
+        end
+      end
+
+      class XTEST51 < XTEST44
+        include MODULETEST51
+      end
+      XTEST51.new.foo(9)
+    ', binding)
+
+    }.should raise_error(SecurityError)
+
+  end
+
+  it "should raise SecurityError when use super with no arguments inside a module nested on class" do
+
+    lambda {
+
+    EvalHook::HookHandler.new.evalhook('
+
+      class CLASSTEST52
+        module MODULETEST52
+          def foo(a)
+            super
+          end
+        end
+      end
+
+      class YTEST52 < XTEST44
+        include CLASSTEST52::MODULETEST52
+      end
+      YTEST52.new.foo(9)
+    ', binding)
+
+    }.should raise_error(SecurityError)
+
+  end
+
+  it "should execute super call from singleton methods" do
+    EvalHook::HookHandler.new.evalhook('
+
+      class CLASSTEST53
+        def bar(a)
+            a+1
+        end
+      end
+
+      obj = CLASSTEST53.new
+
+      def obj.bar(a)
+        super(a+1)
+      end
+      obj.bar(10)
+    ', binding).should be == 12
+  end
+
 end
 

data/spec/hook_handler/hook_handler_hook_spec.rb

@@ -43,4 +43,140 @@ describe EvalHook::HookHandler, "hook handler hooks" do
     TEST_CONSTANT.should be == 7
   end
 
+  it "should intercept constant access" do
+    hh = EvalHook::HookHandler.new
+    def hh.handle_const(name)
+       const_value(77)
+    end
+
+    TEST_CONSTANT_12345 = 8
+    hh.evalhook("TEST_CONSTANT_12345").should be == 77
+  end
+
+  it "should allow change constant values using hooking" do
+    hh = EvalHook::HookHandler.new
+    def hh.handle_colon2(context, name)
+       const_value(77)
+    end
+
+    TEST_CONSTANT_12346 = 8
+    hh.evalhook("Object::TEST_CONSTANT_12346").should be == 77
+  end
+
+  it "should allow change global variable values using hooking" do
+    hh = EvalHook::HookHandler.new
+    def hh.handle_gvar(global_id)
+       global_value(88)
+    end
+
+    $test_global_12345 = 9
+    hh.evalhook("$test_global_12345").should be == 88
+  end
+
+  it "should intercept constant access" do
+    hh = EvalHook::HookHandler.new
+
+    hh.should_receive(:handle_const).with("A")
+
+    hh.evalhook("A")
+  end
+
+  module TestModule321
+  end
+
+  it "should intercept nested constant access" do
+    hh = EvalHook::HookHandler.new
+
+    hh.should_receive(:handle_const).once.with("TestModule321")
+    hh.should_receive(:handle_colon2).once.with(TestModule321,"B")
+
+    hh.evalhook("TestModule321::B")
+  end
+
+  it "should intercept global_variable access" do
+    hh = EvalHook::HookHandler.new
+
+    hh.should_receive(:handle_gvar).with(:$global_variable_test)
+
+    hh.evalhook("$global_variable_test")
+  end
+
+
+  class X
+    def foo
+    end
+  end
+
+  class Y < X
+  end
+
+  it "should intercept super as a method call" do
+    h = EvalHook::HookHandler.new
+
+    # reference to X for inheritance
+    h.should_receive(:handle_const).with("X")
+
+    # reference to Y
+    h.should_receive(:handle_const).with("Y")
+
+    # call to new
+    h.should_receive(:handle_method).with(Y.class,Y,:new)
+
+    # first Y#foo call
+    h.should_receive(:handle_method).with(Y,anything(),:foo)
+
+    # super call
+    h.should_receive(:handle_method).with(X,anything(),:foo)
+
+    h.evalhook('
+
+      class Y < X
+        def foo
+          super
+        end
+      end
+      Y.new.foo
+
+    ', binding)
+  end
+
+  class X2
+    def foo(a)
+      a+1
+    end
+  end
+
+  class Y2 < X2
+  end
+
+  it "should intercept super with explicit arguments as a method call" do
+    h = EvalHook::HookHandler.new
+
+    # reference to X for inheritance
+    h.should_receive(:handle_const).with("X2")
+
+    # reference to Y
+    h.should_receive(:handle_const).with("Y2")
+
+    # call to new
+    h.should_receive(:handle_method).with(Y2.class,Y2,:new)
+
+    # first Y#foo call
+    h.should_receive(:handle_method).with(Y2,anything(),:foo)
+
+    # super call
+    h.should_receive(:handle_method).with(X2,anything(),:foo)
+
+    h.evalhook('
+
+      class Y2 < X2
+        def foo(a)
+          super(a)
+        end
+      end
+      Y2.new.foo(9)
+
+    ', binding).should be == 10
+   end
+
 end

data/spec/hook_handler/hook_handler_visitor_spec.rb

@@ -7,6 +7,10 @@ describe EvalHook::HookHandler, "hook handler visitor" do
     def foo
 
     end
+
+    def bar(*x)
+
+    end
   end
 
   def self.visitor_it(code, name)
@@ -100,4 +104,57 @@ describe EvalHook::HookHandler, "hook handler visitor" do
 
   end
 
+  it "should capture inside parameters" do
+      x = X.new
+      hh = EvalHook::HookHandler.new
+
+      hh.should_receive(:handle_method).with(X,x,:foo)
+      hh.should_receive(:handle_method).with(X,x,:bar)
+
+      c = nil
+      hh.evalhook("
+          x.bar(x.foo)
+        ", binding
+      )
+  end
+
+  it "should capture in global assignment" do
+      x = X.new
+      hh = EvalHook::HookHandler.new
+
+      hh.should_receive(:handle_method).with(X,x,:foo)
+
+      c = nil
+      hh.evalhook("
+          $a = x.foo
+        ", binding
+      )
+  end
+
+  it "should capture in constant assignment" do
+      x = X.new
+      hh = EvalHook::HookHandler.new
+
+      hh.should_receive(:handle_method).with(X,x,:foo)
+
+      c = nil
+      hh.evalhook("
+          TESTCONSTANTA = x.foo
+        ", binding
+      )
+  end
+
+  it "should capture in dxstr system calls" do
+      x = X.new
+      hh = EvalHook::HookHandler.new
+
+      hh.should_receive(:handle_method).with(X,x,:foo)
+
+      c = nil
+      hh.evalhook("
+          `\#{x.foo}`
+        ", binding
+      )
+  end
+
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: evalhook
 version: !ruby/object:Gem::Version 
-  hash: 17
+  hash: 15
   prerelease: false
   segments: 
   - 0
-  - 3
-  - 1
-  version: 0.3.1
+  - 4
+  - 0
+  version: 0.4.0
 platform: ruby
 authors: 
 - Dario Seminara
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-04-10 00:00:00 -03:00
+date: 2011-04-28 00:00:00 -03:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -26,12 +26,12 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        hash: 27
+        hash: 23
         segments: 
         - 0
-        - 1
+        - 2
         - 0
-        version: 0.1.0
+        version: 0.2.0
   type: :runtime
   version_requirements: *id001
 - !ruby/object:Gem::Dependency 
@@ -65,9 +65,9 @@ files:
 - examples/example4.rb
 - examples/example2.rb
 - lib/evalhook/multi_hook_handler.rb
+- lib/evalhook/tree_processor.rb
 - lib/evalhook/hook_handler.rb
 - lib/evalhook/redirect_helper.rb
-- lib/evalhook/hook_context.rb
 - lib/evalhook.rb
 - spec/hook_handler/hook_handler_arguments_spec.rb
 - spec/hook_handler/hook_handler_hook_spec.rb

data/lib/evalhook/hook_context.rb

@@ -1,144 +0,0 @@
-=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 "ruby_parser"
-require "partialruby"
-
-module EvalHook
-  class HookContext < PartialRuby::PureRubyContext
-
-    def initialize(hook_handler)
-      @hook_handler = hook_handler
-    end
-
-    def const_path_emul(code)
-      if code.instance_of? Array
-        if (code.size == 1)
-          s(:const, code[-1].to_sym)
-        else
-          s(:colon2, const_path_emul(code[0..-2]), code[-1].to_sym)
-        end
-      else
-        const_path_emul code.split("::")
-      end
-    end
-
-    def ruby_emul_colon3(tree)
-      if @hook_handler.base_namespace
-        emul s(:colon2, const_path_emul(@hook_handler.base_namespace.to_s), tree[1])
-      else
-        super tree
-      end
-    end
-
-    def ruby_emul_call(tree)
-
-      method_name = tree[2]
-
-      if tree.respond_to?(:is_marked?)
-        return super(tree)
-      end
-
-      args1 = s(:arglist, s(:lit, method_name), marked(s(:call, nil, :binding, s(:arglist))))
-
-      args2 = s(:arglist, s(:lit, @hook_handler))
-
-      receiver = tree[1] || s(:self)
-
-      firstcall = nil
-      secondcall = nil
-
-      if tree[1]
-        firstcall = marked(s(:call, receiver, :local_hooked_method, args1))
-        secondcall = marked(s(:call, firstcall, :set_hook_handler, args2))
-      else
-        firstcall = marked(s(:call, receiver, :hooked_method, args1))
-        secondcall = marked(s(:call, firstcall, :set_hook_handler, args2))
-      end
-
-      super marked(s(:call, secondcall, :call, tree[3]))
-    end
-
-    def ruby_emul_dxstr(tree)
-
-      dstr_tree = tree.dup
-      dstr_tree[0] = :dstr
-
-      args = s(:arglist, dstr_tree )
-
-      emul marked(s(:call, s(:lit, @hook_handler), :hooked_xstr, args))
-    end
-
-    def ruby_emul_xstr(tree)
-      args = s(:arglist, s(:lit, tree[1]) )
-
-      emul marked(s(:call, s(:lit, @hook_handler), :hooked_xstr, args))
-    end
-
-    def ruby_emul_cdecl(tree)
-      const_tree = tree[1]
-      value_tree = tree[2]
-
-      base_class_tree = nil
-      const_id = nil
-
-      unless const_tree.instance_of? Symbol
-        if const_tree[0] == :colon2
-          base_class_tree = const_tree[1]
-          const_id = const_tree[2]
-        elsif const_tree[0] == :colon3
-          base_class_tree = s(:lit, Object)
-          const_id = const_tree[1]
-        end
-      else
-        base_class_tree = s(:lit, Object)
-        const_id = const_tree
-      end
-
-      args1 = s(:arglist, base_class_tree)
-      args2 = s(:arglist, s(:lit, const_id))
-      args3 = s(:arglist, value_tree)
-
-      firstcall = marked(s(:call, s(:lit, @hook_handler), :hooked_cdecl, args1 ))
-      secondcall = marked(s(:call, firstcall, :set_id, args2))
-      thirdcall = marked(s(:call, secondcall, :set_value, args3))
-
-      emul thirdcall
-    end
-
-    def ruby_emul_gasgn(tree)
-      args1 = s(:arglist, s(:lit, tree[1]))
-      args2 = s(:arglist, tree[2] )
-
-      firstcall = marked(s(:call, s(:lit, @hook_handler), :hooked_gasgn, args1))
-      secondcall = marked(s(:call, firstcall, :set_value, args2))
-      emul secondcall
-    end
-
-    private
-
-    def marked(ast)
-      def ast.is_marked?
-        true
-      end
-      ast
-    end
-  end
-end