evalhook 0.2.0 → 0.3.0

data/CHANGELOG

@@ -1,3 +1,5 @@
+0.3.0	Refactor: removed C extension for hooking and use partialruby instead
+
 0.2.0	Added support to hook xstr nodes (system calls with backsticks and %x)
 
 		Added MultiHookHandler (for multiple nested hooks)

data/Rakefile

@@ -6,18 +6,18 @@ require 'rake/gempackagetask'
 
 spec = Gem::Specification.new do |s|
   s.name = 'evalhook'
-  s.version = '0.2.0'
+  s.version = '0.3.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 "evalmimic", ">= 0.1.0"
+  s.add_dependency "partialruby", ">= 0.1.0"
+  s.add_dependency "ruby_parser", ">= 2.0.6"
   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") +
+  s.files = Dir.glob("{examples,lib,spec}/**/*.rb") + Dir.glob("ext/**/*.c") + Dir.glob("ext/**/*.h") + Dir.glob("ext/**/extconf.rb") +
     [ 'LICENSE', 'AUTHORS', 'CHANGELOG', 'README', 'Rakefile', 'TODO' ]
 end
 

data/lib/evalhook/hook_context.rb

@@ -0,0 +1,144 @@
+=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

data/lib/evalhook/hook_handler.rb

@@ -0,0 +1,35 @@
+=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

data/lib/evalhook/multi_hook_handler.rb

@@ -18,7 +18,7 @@ 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/hook_handler"
 
 module EvalHook
 

data/lib/evalhook.rb

@@ -18,19 +18,25 @@ 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 "partialruby"
 require "evalhook/redirect_helper"
 require "evalhook/multi_hook_handler"
+require "evalhook/hook_handler"
+require "evalhook/hook_context"
+begin
 require "evalmimic"
+$evalmimic_defined = true
+rescue LoadError
+$evalmimic_defined = false
+end
 
 
 class Object
-  def local_hooked_method(mname)
-    EvalHook::HookedMethod.new(self,mname,true)
+  def local_hooked_method(mname,_binding)
+    EvalHook::HookedMethod.new(self,mname,true,_binding)
   end
-  def hooked_method(mname)
-    EvalHook::HookedMethod.new(self,mname,false)
+  def hooked_method(mname,_binding)
+    EvalHook::HookedMethod.new(self,mname,false,_binding)
   end
 end
 
@@ -39,10 +45,11 @@ module EvalHook
   # used internally
   class HookedMethod
 
-    def initialize(recv, m,localcall)
+    def initialize(recv, m,localcall,_binding)
       @recv = recv
       @m = m
       @localcall = localcall
+      @_binding = _binding
     end
 
     # used internally
@@ -62,8 +69,15 @@ module EvalHook
       method_handler = @method_handler
       ret = nil
 
-      klass = @klass || @recv.method(@m).owner
       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
@@ -215,35 +229,35 @@ module EvalHook
       runstr = handle_xstr(str) || str
     end
 
-    define_eval_method :evalhook
+    def evalhook_i(code, b_ = nil, name = "(eval)", line = 1)
+
+      EvalHook.validate_syntax code
+
+      tree = RubyParser.new.parse code
+
+      context = EvalHook::HookContext.new(self)
+      emulationcode = context.emul tree
+
+      eval emulationcode, b_, name, line
 
-    # used internally
-    def internal_eval(b_, original_args)
-      raise ArgumentError if original_args.size == 0
-      evalhook_i(original_args[0], original_args[1] || b_, original_args[2] || "(eval)", original_args[3] || 0)
     end
 
-    def evalhook_i(code, b_ = nil, name = "(eval)", line = 1)
+    if ($evalmimic_defined)
 
-      EvalHook.validate_syntax code
+      define_eval_method :evalhook
 
-      code = "
-        retvalue = nil
-        EvalHook.double_run do |run|
-          ( if (run)
-            retvalue = begin
-              #{code}
-            end
-            EvalHook::FakeEvalHook
-          else
-            EvalHook
-          end ).hook_block(ObjectSpace._id2ref(#{object_id}))
-        end
-        retvalue
-       "
-      eval(code, b_, name, line)
+      # used internally
+      def internal_eval(b_, original_args)
+        raise ArgumentError if original_args.size == 0
+        evalhook_i(original_args[0], original_args[1] || b_, original_args[2] || "(eval)", original_args[3] || 0)
+      end
 
+    else
+      def evalhook(*args)
+        evalhook_i(*args)
+      end
     end
+
   end
 
 	module ModuleMethods

data/spec/hook_handler/hook_handler_arguments_spec.rb

@@ -0,0 +1,15 @@
+require "rubygems"
+require "evalhook"
+
+describe EvalHook::HookHandler, "hook handler" do
+
+  it "should accept specified source name" do
+    hh = EvalHook::HookHandler.new
+
+    begin
+      hh.evalhook("raise '0'",binding, "sourcename", 1)
+    rescue Exception => e
+      e.backtrace.join.include? ("sourcename").should be == true
+    end
+  end
+end

data/spec/hook_handler/hook_handler_defaults_spec.rb

@@ -0,0 +1,230 @@
+require "rubygems"
+require "evalhook"
+
+class NilClass
+  def strip
+    ""
+  end
+end
+
+describe EvalHook::HookHandler, "hook handler defaults" do
+   it "should throw exception when call evalhook with no parameters" do
+  		hook_handler = EvalHook::HookHandler.new
+
+  		lambda {
+  			hook_handler.evalhook
+  		}.should raise_error(ArgumentError)
+   end
+
+  exprlist = ["1+1", "[1,2,3].map{|x| x*2}"]
+
+  exprlist.each do |expr|
+    it "should eval expresion '#{expr}' same as eval" do
+      hook_handler = EvalHook::HookHandler.new
+
+      expected = eval(expr)
+      hook_handler.evalhook(expr).should be == expected
+
+    end
+  end
+
+  it "should allow reference to global variables" do
+     hook_handler = EvalHook::HookHandler.new
+
+     $global_variable_test = 5
+     hook_handler.evalhook("$global_variable_test").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
+  end
+
+  it "should allow reference to local variables" do
+     hook_handler = EvalHook::HookHandler.new
+
+     a = 5
+     hook_handler.evalhook("a", binding).should be == a
+  end
+
+
+  class N
+    def foo(hook_handler)
+      @a = 5
+      hook_handler.evalhook("@a", binding)
+    end
+  end
+
+
+  it "should allow reference to instance variables" do
+     hook_handler = EvalHook::HookHandler.new
+     N.new.foo(hook_handler).should be == 5
+  end
+
+  class X
+    def foo
+      3
+    end
+  end
+
+  it "should allow method calls" do
+    hook_handler = EvalHook::HookHandler.new
+    hook_handler.evalhook("X.new.foo").should be X.new.foo
+  end
+
+  it "should capture method calls" do
+    hook_handler = EvalHook::HookHandler.new
+
+    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")
+  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")
+
+  end
+
+  it "should capture global assignment" do
+    hook_handler = EvalHook::HookHandler.new
+
+    hook_handler.should_receive(:handle_gasgn).with(:$test_global_variable,4)
+    hook_handler.evalhook("$test_global_variable = 4")
+
+  end
+
+  it "should capture system exec with backsticks" do
+    hook_handler = EvalHook::HookHandler.new
+
+    hook_handler.should_receive(:handle_xstr).with("echo test")
+    hook_handler.evalhook("`echo test`")
+
+  end
+
+  it "should capture system exec with backsticks and dynamic strings" do
+    hook_handler = EvalHook::HookHandler.new
+
+    hook_handler.should_receive(:handle_xstr).with("echo test")
+    hook_handler.evalhook("`echo \#{}test`")
+
+  end
+
+  it "should capture system exec with %x" do
+    hook_handler = EvalHook::HookHandler.new
+
+    hook_handler.should_receive(:handle_xstr).with("echo test")
+    hook_handler.evalhook("%x[echo test]")
+  end
+
+
+  module B
+
+  end
+  module A
+    module B
+      class C
+
+      end
+
+    end
+  end
+
+  it "should allow define base_namespace" do
+    hook_handler = EvalHook::HookHandler.new
+
+    hook_handler.base_namespace = :A
+    hook_handler.evalhook("::B").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
+  end
+
+  class C1
+    def foo
+      "C1#foo"
+    end
+  end
+  module A1
+    class C1
+      def foo
+        "A1::C1#foo"
+      end
+    end
+  end
+
+  it "should allow define base_namespace (class)" do
+    hook_handler = EvalHook::HookHandler.new
+
+    hook_handler.base_namespace = A1
+    hook_handler.evalhook("class ::C1
+            def foo
+              'A1::C1#foo at evalhook'
+            end
+        end")
+
+    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
+  end
+
+
+  class C2
+    def foo
+      "C2#foo"
+    end
+  end
+
+  it "should default base_namespace to Object" do
+    hook_handler = EvalHook::HookHandler.new
+
+    hook_handler.evalhook("
+
+        module Z
+          class ::C2
+              def foo
+                '::C2#foo at evalhook'
+              end
+          end
+
+        end
+    ")
+
+    C2.new.foo.should be == "::C2#foo at evalhook"
+  end
+
+  module A1
+    module A2
+
+    end
+  end
+
+
+  it "should allow define base_namespace (3 levels)" do
+    hook_handler = EvalHook::HookHandler.new
+
+    hook_handler.base_namespace = A1::A2
+    hook_handler.evalhook("class ::C1
+            def foo
+              'A1::A2::C1#foo at evalhook'
+            end
+        end")
+
+    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
+  end
+end
+

data/spec/hook_handler/hook_handler_hook_spec.rb

@@ -0,0 +1,46 @@
+require "rubygems"
+require "evalhook"
+
+describe EvalHook::HookHandler, "hook handler hooks" do
+
+  class X2
+    def foo
+      9
+    end
+
+    def bar
+      4
+    end
+  end
+
+  it "should intercept and change method calls" do
+    hh = EvalHook::HookHandler.new
+    def hh.handle_method(klass, recv, method_name)
+      redirect_method(klass, recv, :bar)
+    end
+
+    x = X2.new
+    hh.evalhook("x.foo", binding).should be == 4
+  end
+
+  it "should intercept and change global variable assignments" do
+    hh = EvalHook::HookHandler.new
+    def hh.handle_gasgn(global_id, value)
+      redirect_gasgn(global_id, 7)
+    end
+
+    hh.evalhook("$test_global_variable = 9")
+    $test_global_variable.should be == 7
+  end
+
+  it "should intercept and change constant assignments" do
+    hh = EvalHook::HookHandler.new
+    def hh.handle_cdecl(context, name, value)
+       redirect_cdecl(context,name,7)
+    end
+
+    hh.evalhook("TEST_CONSTANT = 9")
+    TEST_CONSTANT.should be == 7
+  end
+
+end

data/spec/hook_handler/hook_handler_multiple_redirect_spec.rb

@@ -0,0 +1,67 @@
+require "rubygems"
+require "evalhook"
+
+describe EvalHook::MultiHookHandler, "multiple hook handler redirect" do
+
+   class X
+     def self.foo
+
+     end
+   end
+
+   handles = [
+    [:handle_method, "X.foo"],
+    [:handle_cdecl, "TEST_CONSTANT = 4"],
+    [:handle_gasgn, "$test_global_variable = 4"] ]
+
+   handles.each do |handle|
+    it "should recall #{handle[0]} in correct order" do
+      hook_handler = EvalHook::MultiHookHandler.new
+
+      nested_handler_1 = EvalHook::HookHandler.new
+      nested_handler_2 = EvalHook::HookHandler.new
+      hook_handler.add nested_handler_1
+      hook_handler.add nested_handler_2
+
+      nested_handler_1.should_receive(handle[0])
+      nested_handler_2.should_receive(handle[0])
+
+      hook_handler.evalhook(handle[1])
+    end
+  end
+
+   class X_
+     def foo
+      nil
+     end
+
+     def bar
+       nil
+     end
+   end
+
+
+  it "should handle redirects on recall of handle_method" do
+      hook_handler = EvalHook::MultiHookHandler.new
+
+      nested_handler_1 = EvalHook::HookHandler.new
+      nested_handler_2 = EvalHook::HookHandler.new
+      hook_handler.add nested_handler_1
+      hook_handler.add nested_handler_2
+
+      x = X_.new
+
+      def nested_handler_1.handle_method(klass, recv, m )
+        RedirectHelper::Redirect.new(klass, recv, :bar)
+      end
+
+      nested_handler_2.should_receive(:handle_method).
+                        with(X_, x, :bar).
+                        and_return(nil)
+
+      hook_handler.evalhook("x.foo", binding)
+
+
+  end
+
+end