evalhook 0.4.1 → 0.5.0

data/CHANGELOG

@@ -1,3 +1,9 @@
+0.5.0	Implemented code packets (see documentation)
+
+		Refactor of hooking of call, super and zsuper nodes to improve performance
+
+		Refactor of spec to be compatible with ruby 1.9
+ 
 0.4.1	Fixed bug on hooking of node type super (lack of hooking for arguments)
 
 0.4.0	Removed evalmimic dependency

data/Rakefile

@@ -6,7 +6,7 @@ require 'rake/gempackagetask'
 
 spec = Gem::Specification.new do |s|
   s.name = 'evalhook'
-  s.version = '0.4.1'
+  s.version = '0.5.0'
   s.author = 'Dario Seminara'
   s.email = 'robertodarioseminara@gmail.com'
   s.platform = Gem::Platform::RUBY

data/lib/evalhook/multi_hook_handler.rb

@@ -18,10 +18,12 @@ 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/hook_handler"
-
 module EvalHook
 
+class HookHandler
+
+end
+
 class MultiHookHandler < HookHandler
   def initialize
     @nested_hook_handlers = Array.new

data/lib/evalhook/tree_processor.rb

@@ -59,37 +59,34 @@ module EvalHook
 
     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)
+      args1 = s(:arglist, s(:lit, tree[1]), process(tree[2]))
 
+      s(:call, hook_handler_reference, :hooked_gasgn, args1)
     end
 
 
     def process_call(tree)
+      original_receiver = tree[1]
 
-          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)
+      receiver = process(original_receiver|| s(:self))
 
-          firstcall = nil
-          secondcall = nil
+      firstcall = 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
+      if tree[3] == s(:arglist)
+        firstcall = s(:call,
+            hook_handler_reference,
+            :hooked_variable_method,
+            s(:arglist, receiver, s(:lit, tree[2]), s(:call, nil, :binding, s(:arglist)))
+            )
+      else
+        firstcall = s(:call,
+            hook_handler_reference,
+            :hooked_method,
+            s(:arglist, receiver, s(:lit, tree[2]))
+            )
+      end
 
-          s(:call, secondcall, :call, process(tree[3]))
+      s(:call, firstcall, :call, process(tree[3]))
     end
 
     def process_cdecl(tree)
@@ -113,14 +110,9 @@ module EvalHook
             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)
+          args1 = s(:arglist, base_class_tree, s(:lit, const_id), process(value_tree))
 
-          s(:call, secondcall, :set_value, args3)
+          s(:call, hook_handler_reference, :hooked_cdecl, args1 )
     end
 
     def process_dxstr(tree)
@@ -231,16 +223,12 @@ module EvalHook
 
           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))
+          firstcall = s(:call, hook_handler_reference,
+                :hooked_method,
+                s(:arglist, receiver, s(:lit,@last_method_name), superclass_call_tree))
 
           # pass the args passed to super
-          s(:call, thirdcall, :call, process(s(:arglist, *tree[1..-1])))
-
+          s(:call, firstcall, :call, process(s(:arglist, *tree[1..-1])))
     end
 
     def process_defs(tree)
@@ -254,15 +242,11 @@ module EvalHook
 
           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))
+          firstcall = s(:call, hook_handler_reference,
+                :hooked_method,
+                s(:arglist, receiver, s(:lit,@last_method_name), 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] == "*"
@@ -272,7 +256,7 @@ module EvalHook
             end
           end
 
-          s(:call, thirdcall, :call, args)
+          s(:call, firstcall, :call, args)
     end
 
 end

data/lib/evalhook.rb

@@ -21,7 +21,6 @@ along with evalhook.  if not, see <http://www.gnu.org/licenses/>.
 require "partialruby"
 require "evalhook/redirect_helper"
 require "evalhook/multi_hook_handler"
-require "evalhook/hook_handler"
 require "evalhook/tree_processor"
 
 begin
@@ -31,87 +30,33 @@ rescue LoadError
 $evalmimic_defined = false
 end
 
-
-class Object
-  def local_hooked_method(mname,_binding)
-    EvalHook::HookedMethod.new(self,mname,true,_binding)
-  end
-  def hooked_method(mname,_binding)
-    EvalHook::HookedMethod.new(self,mname,false,_binding)
-  end
-end
-
 module EvalHook
 
   # used internally
-  class HookedMethod
-
-    def initialize(recv, m,localcall,_binding)
-      @recv = recv
-      @m = m
-      @localcall = localcall
-      @_binding = _binding
-    end
-
-    # used internally
-    def set_hook_handler(method_handler)
-      @method_handler = method_handler
-      self
-    end
-
-    # used internally
-    def set_class(klass)
-      @klass = klass
-      self
+  class FakeEvalHook
+    def self.hook_block(*args)
     end
+  end
 
-    # used internally
-    def call(*args)
-      method_handler = @method_handler
-      ret = nil
-
-      method_name = @m
-      if args.length == 0
-        local_vars = @_binding.eval("local_variables").map(&:to_s)
-        if local_vars.include? method_name.to_s
-          return @_binding.eval(method_name.to_s)
-        end
-      end
-
-      klass = @klass || @recv.method(@m).owner
-      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
-
-      method_object = nil
-
-      begin
-        method_object = klass.instance_method(method_name).bind(recv)
-      rescue
-        method_object = recv.method(method_name)
-      end
-
-      if block_given?
-        method_object.call(*args) do |*x|
-          yield(*x)
-        end
-      else
-        method_object.call(*args)
-      end
+  class Packet
+    def initialize(emulationcode) #:nodoc:
+      @emulationcode = emulationcode
     end
-  end
 
-  # used internally
-  class FakeEvalHook
-    def self.hook_block(*args)
+    # Executes the code with a given binding, source name (optional) and line (optional)
+    #
+    # See EvalHook::HookHandler#packet for more info
+    #
+    # Example:
+    #
+    #   hook_handler = HookHandler.new
+    #
+    #   pack = hook_handler.packet('print "hello world\n"')
+    #   10.times do
+    #     pack.run
+    #   end
+    def run(binding_, name = "(eval)", line = 1)
+      eval(@emulationcode, binding_, name, line)
     end
   end
 
@@ -134,57 +79,7 @@ module EvalHook
       end
     end
 
-    # 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_gvar(global_id)
+    def hooked_gvar(global_id) #:nodoc:
       ret = handle_gvar(global_id)
       if ret
         ret.value
@@ -193,8 +88,7 @@ module EvalHook
       end
     end
 
-    # used internally
-    def hooked_const(name)
+    def hooked_const(name) #:nodoc:
       ret = handle_const(name)
       if ret
         ret.value
@@ -203,8 +97,7 @@ module EvalHook
        end
     end
 
-    # used internally
-    def hooked_colon2(context,name)
+    def hooked_colon2(context,name) #:nodoc:
       ret = handle_colon2(context, name)
       if ret
         ret.value
@@ -213,14 +106,86 @@ module EvalHook
       end
     end
 
-    # used internally
-    def hooked_cdecl(context)
-      HookCdecl.new(context,self)
+    def hooked_cdecl(klass, const_id, value) #:nodoc:
+      ret = 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
 
-    # used internally
-    def hooked_gasgn(global_id)
-      HookGasgn.new(global_id,self)
+    def hooked_gasgn(global_id, value) #:nodoc:
+      ret = handle_gasgn(global_id, value)
+
+      if ret then
+        global_id = ret.global_id
+        value = ret.value
+      end
+      eval("#{global_id} = value")
+    end
+
+    class HookedCallValue
+      def initialize(value)
+        @value = value
+      end
+      def call(*args)
+        @value
+      end
+    end
+
+    def hooked_method(receiver, mname, klass = nil) #:nodoc:
+      m = nil
+      unless klass
+        m = receiver.method(mname)
+        klass = m.owner
+      else
+        m = klass.instance_method(mname).bind(receiver)
+      end
+
+      ret = handle_method(klass, receiver, mname )
+
+      if ret.kind_of? RedirectHelper::MethodRedirect
+        klass = ret.klass
+        mname = ret.method_name
+        receiver = ret.recv
+
+        begin
+          m = ret.klass.instance_method(ret.method_name).bind(ret.recv)
+        rescue
+          m = ret.recv.method(ret.method_name)
+        end
+      end
+
+      m
+    end
+
+    def hooked_variable_method(receiver, mname, _binding) #:nodoc:
+      local_vars = _binding.eval("local_variables").map(&:to_s)
+      if local_vars.include? mname.to_s
+        HookedCallValue.new( _binding.eval(mname.to_s) )
+      else
+        m = receiver.method(mname)
+        klass = m.owner
+        ret = handle_method(klass, receiver, mname )
+
+        if ret.kind_of? RedirectHelper::MethodRedirect
+          klass = ret.klass
+          mname = ret.method_name
+          receiver = ret.recv
+
+          begin
+            m = ret.klass.instance_method(ret.method_name).bind(ret.recv)
+          rescue
+            m = ret.recv.method(ret.method_name)
+          end
+        end
+
+        m
+      end
     end
 
     # Overwrite to handle the assignment/creation of global variables. By default do nothing but assign the variable. See examples
@@ -262,31 +227,37 @@ module EvalHook
       nil
     end
 
-    # used internally
-    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
-
-    # used internally
-    def hooked_xstr(str)
+    def hooked_xstr(str) #:nodoc:
       runstr = handle_xstr(str) || str
     end
 
     def evalhook_i(code, b_ = nil, name = "(eval)", line = 1)
+      packet(code).run(b_,name,line)
+    end
 
-      EvalHook.validate_syntax code
+    # Creates a packet of preprocessed ruby code to run it later
+    # , useful to execute the same code repeatedly and avoid heavy
+    # preprocessing of ruby code all the times.
+    #
+    # See EvalHook::Packet for more information
+    #
+    # Example:
+    #
+    #   hook_handler = HookHandler.new
+    #
+    #   pack = hook_handler.packet('print "hello world\n"')
+    #   10.times do
+    #     pack.run
+    #   end
+    def packet(code)
+
+      tree = nil
 
-      tree = RubyParser.new.parse code
+      begin
+        tree = RubyParser.new.parse code
+      rescue
+        raise SyntaxError
+      end
 
       context = PartialRuby::PureRubyContext.new
 
@@ -294,8 +265,7 @@ module EvalHook
 
       emulationcode = context.emul tree
 
-      eval emulationcode, b_, name, line
-
+      EvalHook::Packet.new(emulationcode)
     end
 
     if ($evalmimic_defined)

data/spec/hook_handler/hook_handler_arguments_spec.rb

@@ -9,7 +9,7 @@ describe EvalHook::HookHandler, "hook handler" do
     begin
       hh.evalhook("raise '0'",binding, "sourcename", 1)
     rescue Exception => e
-      e.backtrace.join.include? ("sourcename").should be == true
+      e.backtrace.join.include?("sourcename").should be == true
     end
   end
 end

data/spec/hook_handler/hook_handler_defaults_spec.rb

@@ -7,6 +7,8 @@ class NilClass
   end
 end
 
+$top_level_binding = binding
+
 describe EvalHook::HookHandler, "hook handler defaults" do
    it "should throw exception when call evalhook with no parameters" do
   		hook_handler = EvalHook::HookHandler.new
@@ -38,7 +40,7 @@ describe EvalHook::HookHandler, "hook handler defaults" do
   it "should allow reference to constants" do
      hook_handler = EvalHook::HookHandler.new
 
-     CONSTANTTEST = 5
+     ::CONSTANTTEST = 5
      hook_handler.evalhook("CONSTANTTEST", binding).should be == CONSTANTTEST
   end
 
@@ -63,7 +65,7 @@ describe EvalHook::HookHandler, "hook handler defaults" do
      N.new.foo(hook_handler).should be == 5
   end
 
-  class X
+  class ::X
     def foo
       3
     end
@@ -71,7 +73,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", binding).should be X.new.foo
+    hook_handler.evalhook("X.new.foo", binding).should be(X.new.foo)
   end
 
   it "should capture method calls" do
@@ -123,10 +125,10 @@ describe EvalHook::HookHandler, "hook handler defaults" do
   end
 
 
-  module B
+  module ::B
 
   end
-  module A
+  module ::A
     module B
       class C
 
@@ -138,23 +140,23 @@ describe EvalHook::HookHandler, "hook handler defaults" do
   it "should allow define base_namespace" do
     hook_handler = EvalHook::HookHandler.new
 
-    hook_handler.base_namespace = :A
-    hook_handler.evalhook("::B", binding).should be == A::B
+    hook_handler.base_namespace = ::A
+    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", binding).should be == A::B
+    hook_handler.base_namespace = ::A
+    hook_handler.evalhook("::B", binding).should be == ::A::B
   end
 
-  class C1
+  class ::C1
     def foo
       "C1#foo"
     end
   end
-  module A1
+  module ::A1
     class C1
       def foo
         "A1::C1#foo"
@@ -165,7 +167,7 @@ describe EvalHook::HookHandler, "hook handler defaults" do
   it "should allow define base_namespace (class)" do
     hook_handler = EvalHook::HookHandler.new
 
-    hook_handler.base_namespace = A1
+    hook_handler.base_namespace = ::A1
     hook_handler.evalhook("class ::C1
             def foo
               'A1::C1#foo at evalhook'
@@ -177,7 +179,7 @@ describe EvalHook::HookHandler, "hook handler defaults" do
   end
 
 
-  class C2
+  class ::C2
     def foo
       "C2#foo"
     end
@@ -201,7 +203,7 @@ describe EvalHook::HookHandler, "hook handler defaults" do
     C2.new.foo.should be == "::C2#foo at evalhook"
   end
 
-  module A1
+  module ::A1
     module A2
 
     end
@@ -211,7 +213,7 @@ describe EvalHook::HookHandler, "hook handler defaults" do
   it "should allow define base_namespace (3 levels)" do
     hook_handler = EvalHook::HookHandler.new
 
-    hook_handler.base_namespace = A1::A2
+    hook_handler.base_namespace = ::A1::A2
     hook_handler.evalhook("class ::C1
             def foo
               'A1::A2::C1#foo at evalhook'
@@ -226,7 +228,7 @@ describe EvalHook::HookHandler, "hook handler defaults" do
     EvalHook::HookHandler.new.evalhook("class Fixnum::TestClass12345; end", binding)
   end
 
-  module TestInheritedClassMethodError
+  module ::TestInheritedClassMethodError
     class A
         def self.foo
             'Foo'
@@ -246,54 +248,54 @@ describe EvalHook::HookHandler, "hook handler defaults" do
     EvalHook::HookHandler.new.evalhook("module Fixnum::TestModule12345; end", binding)
   end
 
-  module TestModule12347
+  module ::TestModule12347
   end
 
   it "should allow assignment of constants nested on modules" do
     EvalHook::HookHandler.new.evalhook("TestModule12347::A = 9", binding)
   end
 
-  class XTEST44
+  class ::XTEST44
     def foo(a)
       a+1
     end
   end
   it "should pass arguments on super" do
     EvalHook::HookHandler.new.evalhook('
-      class YTEST44 < XTEST44
+      class ::YTEST44 < XTEST44
         def foo(a)
           super
         end
       end
-      YTEST44.new.foo(9)
+      ::YTEST44.new.foo(9)
     ', binding).should be == 10
   end
 
   it "should pass arguments on super (explicitly)" do
     EvalHook::HookHandler.new.evalhook('
-      class YTEST45 < XTEST44
+      class ::YTEST45 < XTEST44
         def foo(a)
           super(a)
         end
       end
-      YTEST45.new.foo(9)
+      ::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
+      class ::YTEST46 < XTEST44
         def foo(a)
           super(a)
         end
       end
 
-      class ZTEST46 < YTEST46
+      class ::ZTEST46 < ::YTEST46
         def foo(a)
           super(a)
         end
       end
-      ZTEST46.new.foo(9)
+      ::ZTEST46.new.foo(9)
     ', binding).should be == 10
 
   end
@@ -303,16 +305,16 @@ describe EvalHook::HookHandler, "hook handler defaults" do
     lambda {
 
     EvalHook::HookHandler.new.evalhook('
-      module MODULETEST48
+      module ::MODULETEST48
         def foo(a)
           super(a)
         end
       end
 
-      class XTEST48 < XTEST44
-        include MODULETEST48
+      class ::XTEST48 < XTEST44
+        include ::MODULETEST48
       end
-      XTEST48.new.foo(9)
+      ::XTEST48.new.foo(9)
     ', binding)
 
     }.should raise_error(SecurityError)
@@ -325,7 +327,7 @@ describe EvalHook::HookHandler, "hook handler defaults" do
 
     EvalHook::HookHandler.new.evalhook('
 
-      class CLASSTEST49
+      class ::CLASSTEST49
         module MODULETEST49
           def foo(a)
             super(a)
@@ -333,10 +335,10 @@ describe EvalHook::HookHandler, "hook handler defaults" do
         end
       end
 
-      class YTEST49 < XTEST44
+      class ::YTEST49 < XTEST44
         include CLASSTEST49::MODULETEST49
       end
-      YTEST49.new.foo(9)
+      ::YTEST49.new.foo(9)
     ', binding)
 
     }.should raise_error(SecurityError)
@@ -345,18 +347,18 @@ describe EvalHook::HookHandler, "hook handler defaults" do
 
   it "should pass arguments on super with no arguments throught three levels" do
     EvalHook::HookHandler.new.evalhook('
-      class YTEST50 < XTEST44
+      class ::YTEST50 < XTEST44
         def foo(a)
           super
         end
       end
 
-      class ZTEST50 < YTEST50
+      class ::ZTEST50 < ::YTEST50
         def foo(a)
           super
         end
       end
-      ZTEST50.new.foo(9)
+      ::ZTEST50.new.foo(9)
     ', binding).should be == 10
 
   end
@@ -366,16 +368,16 @@ describe EvalHook::HookHandler, "hook handler defaults" do
     lambda {
 
     EvalHook::HookHandler.new.evalhook('
-      module MODULETEST51
+      module ::MODULETEST51
         def foo(a)
           super
         end
       end
 
-      class XTEST51 < XTEST44
-        include MODULETEST51
+      class ::XTEST51 < ::XTEST44
+        include ::MODULETEST51
       end
-      XTEST51.new.foo(9)
+      ::XTEST51.new.foo(9)
     ', binding)
 
     }.should raise_error(SecurityError)
@@ -388,7 +390,7 @@ describe EvalHook::HookHandler, "hook handler defaults" do
 
     EvalHook::HookHandler.new.evalhook('
 
-      class CLASSTEST52
+      class ::CLASSTEST52
         module MODULETEST52
           def foo(a)
             super
@@ -396,10 +398,10 @@ describe EvalHook::HookHandler, "hook handler defaults" do
         end
       end
 
-      class YTEST52 < XTEST44
-        include CLASSTEST52::MODULETEST52
+      class ::YTEST52 < ::XTEST44
+        include ::CLASSTEST52::MODULETEST52
       end
-      YTEST52.new.foo(9)
+      ::YTEST52.new.foo(9)
     ', binding)
 
     }.should raise_error(SecurityError)
@@ -409,13 +411,13 @@ describe EvalHook::HookHandler, "hook handler defaults" do
   it "should execute super call from singleton methods" do
     EvalHook::HookHandler.new.evalhook('
 
-      class CLASSTEST53
+      class ::CLASSTEST53
         def bar(a)
             a+1
         end
       end
 
-      obj = CLASSTEST53.new
+      obj = ::CLASSTEST53.new
 
       def obj.bar(a)
         super(a+1)
@@ -424,5 +426,17 @@ describe EvalHook::HookHandler, "hook handler defaults" do
     ', binding).should be == 12
   end
 
+  it "should reference constants in same context" do
+    EvalHook::HookHandler.new.evalhook("XCONSTANT=9; XCONSTANT", binding).should be == 9
+  end
+
+  it "should reference classes in same context" do
+    EvalHook::HookHandler.new.evalhook("class XCLASS; end; XCLASS", $top_level_binding)
+  end
+
+  it "should reference modules in same context" do
+    EvalHook::HookHandler.new.evalhook("module XMODULE; end; XMODULE", $top_level_binding)
+  end
+
 end
 

data/spec/hook_handler/hook_handler_hook_spec.rb

@@ -76,7 +76,9 @@ describe EvalHook::HookHandler, "hook handler hooks" do
   it "should intercept constant access" do
     hh = EvalHook::HookHandler.new
 
-    hh.should_receive(:handle_const).with("A")
+   hh.should_receive(:handle_const).with("A") {
+	RedirectHelper::Value.new(0)
+   }
 
     hh.evalhook("A")
   end
@@ -87,8 +89,13 @@ describe EvalHook::HookHandler, "hook handler hooks" do
   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.should_receive(:handle_const).once.with("TestModule321") {
+	RedirectHelper::Value.new(TestModule321)
+    }
+
+    hh.should_receive(:handle_colon2).once.with(TestModule321,"B") {
+	RedirectHelper::Value.new(0)
+    }
 
     hh.evalhook("TestModule321::B")
   end
@@ -114,19 +121,53 @@ describe EvalHook::HookHandler, "hook handler hooks" do
     h = EvalHook::HookHandler.new
 
     # reference to X for inheritance
-    h.should_receive(:handle_const).with("X")
+    h.should_receive(:handle_const).with("X") {
+    	RedirectHelper::Value.new(X)
+    }
 
     # reference to Y
-    h.should_receive(:handle_const).with("Y")
+    h.should_receive(:handle_const).with("Y") {
+    	RedirectHelper::Value.new(Y)
+    }
+
+
+    h.instance_eval {
+    @called1 = 0
+    @called2 = 0
+    @called3 = 0
+    }
+
+    def h.handle_method(klass,recv,method_name)
+
+	if klass == Y.class
+	  unless method_name == :new
+          raise Rspec::Mocks::MockExpectationError,  "#{recv} received :handle_method with unexpected arguments"
+	  end
+	  @called1 = @called1 + 1
+	elsif klass == Y
+	  unless method_name == :foo
+          raise Rspec::Mocks::MockExpectationError,  "#{recv} received :handle_method with unexpected arguments"
+	  end
+	  @called2 = @called2 + 1
+	elsif klass == X
+	  unless method_name == :foo
+          raise Rspec::Mocks::MockExpectationError,  "#{recv} received :handle_method with unexpected arguments"
+	  end
+  	  @called3 = @called3 + 1
+        else
+          raise Rspec::Mocks::MockExpectationError,  "#{recv} received unexpected :handle_method"
+	end
+    end
 
+    # rspec doesn't work for ruby1.9 in that way
     # call to new
-    h.should_receive(:handle_method).with(Y.class,Y,:new)
+    #h.should_receive(:handle_method).with(Y.class,anything(),:new)
 
     # first Y#foo call
-    h.should_receive(:handle_method).with(Y,anything(),:foo)
+    #h.should_receive(:handle_method).with(Y,anything(),:foo)
 
     # super call
-    h.should_receive(:handle_method).with(X,anything(),:foo)
+    #h.should_receive(:handle_method).with(X,anything(),:foo)
 
     h.evalhook('
 
@@ -138,6 +179,10 @@ describe EvalHook::HookHandler, "hook handler hooks" do
       Y.new.foo
 
     ', binding)
+
+    h.instance_eval{@called1}.should be == 1
+    h.instance_eval{@called2}.should be == 1
+    h.instance_eval{@called3}.should be == 1
   end
 
   class X2
@@ -153,19 +198,54 @@ describe EvalHook::HookHandler, "hook handler hooks" do
     h = EvalHook::HookHandler.new
 
     # reference to X for inheritance
-    h.should_receive(:handle_const).with("X2")
+    h.should_receive(:handle_const).with("X2") {
+    	RedirectHelper::Value.new(X2)
+    }
 
     # reference to Y
-    h.should_receive(:handle_const).with("Y2")
+    h.should_receive(:handle_const).with("Y2") {
+    	RedirectHelper::Value.new(Y2)
+    }
+
+    h.instance_eval {
+    @called1 = 0
+    @called2 = 0
+    @called3 = 0
+    }
+
+    def h.handle_method(klass,recv,method_name)
+
+	if klass == Y2.class
+	  unless method_name == :new
+          raise Rspec::Mocks::MockExpectationError,  "#{recv} received :handle_method with unexpected arguments"
+	  end
+	  @called1 = @called1 + 1
+	  super(klass,recv,method_name)
+	elsif klass == Y2
+	  unless method_name == :foo
+          raise Rspec::Mocks::MockExpectationError,  "#{recv} received :handle_method with unexpected arguments"
+	  end
+	  @called2 = @called2 + 1
+	  super(klass,recv,method_name)
+	elsif klass == X2
+	  unless method_name == :foo
+          raise Rspec::Mocks::MockExpectationError,  "#{recv} received :handle_method with unexpected arguments"
+	  end
+  	  @called3 = @called3 + 1
+	  super(klass,recv,method_name)
+        else
+          raise Rspec::Mocks::MockExpectationError,  "#{recv} received unexpected :handle_method"
+	end
+    end
 
     # call to new
-    h.should_receive(:handle_method).with(Y2.class,Y2,:new)
+    #h.should_receive(:handle_method).with(Y2.class,Y2,:new)
 
     # first Y#foo call
-    h.should_receive(:handle_method).with(Y2,anything(),:foo)
+    #h.should_receive(:handle_method).with(Y2,anything(),:foo)
 
     # super call
-    h.should_receive(:handle_method).with(X2,anything(),:foo)
+    #h.should_receive(:handle_method).with(X2,anything(),:foo)
 
     h.evalhook('
 
@@ -177,6 +257,11 @@ describe EvalHook::HookHandler, "hook handler hooks" do
       Y2.new.foo(9)
 
     ', binding).should be == 10
+
+    h.instance_eval{@called1}.should be == 1
+    h.instance_eval{@called2}.should be == 1
+    h.instance_eval{@called3}.should be == 1
+
    end
 
   class Y9 < X2
@@ -186,22 +271,32 @@ describe EvalHook::HookHandler, "hook handler hooks" do
     h = EvalHook::HookHandler.new
 
     # reference to X for inheritance
-    h.should_receive(:handle_const).with("X2")
+    h.should_receive(:handle_const).with("X2"){
+      RedirectHelper::Value.new(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)
-
-    # call Y#bar
-    h.should_receive(:handle_method).with(Y2,anything(),:bar)
-
-    # super call
-    h.should_receive(:handle_method).with(X2,anything(),:foo)
+    h.should_receive(:handle_const).with("Y2") {
+      RedirectHelper::Value.new(Y2)
+    }
+
+    h.instance_eval {
+    @called1 = 0
+    @called2 = 0
+    @called3 = 0
+    }
+
+    def h.handle_method(klass,recv,mname)
+      if recv == Y2 and mname == :new
+        @called1 = 1
+      end
+      if mname == :foo
+        @called2 = @called2 + 1
+      end
+      if klass == Y2 and mname == :bar
+        @called3 = 1
+      end
+    end
 
     h.evalhook('
 
@@ -217,5 +312,9 @@ describe EvalHook::HookHandler, "hook handler hooks" do
 
     ', binding).should be == 10
 
+    h.instance_eval{@called1}.should be == 1
+    h.instance_eval{@called2}.should be == 2
+    h.instance_eval{@called3}.should be == 1
+
    end
 end

data/spec/hook_handler/hook_handler_multiple_redirect_spec.rb

@@ -3,7 +3,7 @@ require "evalhook"
 
 describe EvalHook::MultiHookHandler, "multiple hook handler redirect" do
 
-   class X
+   class ::X
      def self.foo
 
      end

data/spec/hook_handler/hook_handler_multiple_spec.rb

@@ -19,7 +19,7 @@ describe EvalHook::MultiHookHandler, "multiple hook handler" do
     end
   end
 
-  class X
+  class ::X
     def foo
 
     end
@@ -27,7 +27,7 @@ describe EvalHook::MultiHookHandler, "multiple hook handler" 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").should be(X.new.foo)
   end
 
   it "should capture method calls" do

data/spec/hook_handler/hook_handler_package_spec.rb

@@ -0,0 +1,23 @@
+require "rubygems"
+require "evalhook"
+
+describe EvalHook::HookHandler, "hook handler" do
+
+  it "should return package of code" do
+    hh = EvalHook::HookHandler.new
+
+    lambda {
+      hh.packet("0")
+    }.should_not raise_error
+
+  end
+
+  it "should execute package of code" do
+    hh = EvalHook::HookHandler.new
+
+    lambda {
+      hh.packet("0").run(binding).should be == 0
+    }.should_not raise_error
+
+  end
+end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: evalhook
 version: !ruby/object:Gem::Version 
-  hash: 13
+  hash: 11
   prerelease: false
   segments: 
   - 0
-  - 4
-  - 1
-  version: 0.4.1
+  - 5
+  - 0
+  version: 0.5.0
 platform: ruby
 authors: 
 - Dario Seminara
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-06-09 00:00:00 -03:00
+date: 2011-06-20 00:00:00 -03:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -66,7 +66,6 @@ files:
 - 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.rb
 - spec/hook_handler/hook_handler_arguments_spec.rb
@@ -75,6 +74,7 @@ files:
 - spec/hook_handler/hook_handler_multiple_spec.rb
 - spec/hook_handler/hook_handler_visitor_spec.rb
 - spec/hook_handler/hook_handler_ruby_spec.rb
+- spec/hook_handler/hook_handler_package_spec.rb
 - spec/hook_handler/hook_handler_defaults_spec.rb
 - spec/validation/hook_handler_spec.rb
 - LICENSE

data/lib/evalhook/hook_handler.rb

@@ -1,35 +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"
-
-module EvalHook
-  def self.validate_syntax(code)
-   begin
-      RubyParser.new.parse(code)
-   rescue
-      raise SyntaxError
-   end
-   true
-  end
-
-  class HookHandler
-  end
-end