mvz-live_ast 1.1.0

data/test/nested_test.rb

@@ -0,0 +1,29 @@
+require_relative 'main'
+
+class NestedTest < RegularTest
+  def test_lambda
+    a = lambda {
+      lambda {
+        "33"
+      }
+    }
+    
+    assert_equal nested_lambdas("33"), a.to_ast
+    assert_equal no_arg_block(:lambda, "33"), a.call.to_ast
+  end
+
+  class A
+    def f
+      Class.new do
+        def g
+          "44"
+        end
+      end
+    end
+  end
+
+  def test_defs
+    assert_equal nested_defs(:f, :g, "44"), A.instance_method(:f).to_ast
+    assert_equal no_arg_def(:g, "44"), A.new.f.instance_method(:g).to_ast
+  end
+end

data/test/noninvasive_test.rb

@@ -0,0 +1,51 @@
+require_relative 'main'
+
+class AAA_NoninvasiveTest < BaseTest
+  def test_no_clutter
+    [Method, UnboundMethod, Proc].each do |klass|
+      assert !klass.instance_methods.include?(:to_ast)
+      assert !klass.instance_methods.include?(:to_ruby)
+    end
+    
+    assert !respond_to?(:ast_eval)
+    assert !Kernel.respond_to?(:ast_eval)
+    assert !respond_to?(:ast_load)
+    assert !Kernel.respond_to?(:ast_load)
+  end
+
+  DEFINE_A = lambda do
+    class A
+      def f
+        "A#f"
+      end
+    end
+  end
+
+  def test_method
+    DEFINE_A.call
+
+    expected = no_arg_def(:f, "A#f")
+    assert_equal expected, LiveAST.ast(A.instance_method(:f))
+    assert_equal expected, LiveAST.ast(A.new.method(:f))
+  end
+
+  def test_lambda
+    a = lambda { |x, y| x ** y }
+
+    assert_equal binop_block(:lambda, :**), LiveAST.ast(a)
+  end
+
+  def test_ast_eval
+    code = %{ lambda { |x, y| x / y } }
+    
+    expected = binop_block(:lambda, :/)
+    result = LiveAST.ast(LiveAST.eval(code, binding))
+    assert_equal expected, result
+  end
+
+  def test_bogus
+    assert_raises TypeError do
+      LiveAST.ast(99)
+    end
+  end
+end

data/test/readme_test.rb

@@ -0,0 +1,16 @@
+require_relative 'main'
+require_relative '../devel/levitate'
+
+if LiveAST.parser::Test.respond_to?(:unified_sexp?) and
+    LiveAST.parser::Test.unified_sexp? and
+    RUBY_ENGINE != "jruby" then  # jruby takes about a minute
+  sections = [
+    "Synopsis",
+    "+to_ruby+",
+    "Noninvasive Interface",
+    "Pure Ruby and +ast_eval+",
+    "Full Integration",
+  ]
+
+  Levitate.doc_to_test("README.rdoc", *sections)
+end

data/test/recursive_eval_test.rb

@@ -0,0 +1,52 @@
+require_relative 'main'
+
+class RecursiveEvalTest < RegularTest
+  DEFINE = lambda do
+    ast_eval %{
+      class A
+        ast_eval %{
+          def f
+            "A#f"
+          end
+        }, binding
+  
+        ast_eval %{
+          ast_eval %{
+            remove_method :f
+            def f(x, y)
+              x + y
+            end
+
+            def g
+              "A#g"
+            end
+          }, binding
+  
+          LAMBDA = ast_eval %{
+            lambda { |x, y| x * y }
+          }, binding
+        }, binding
+      end
+    }, binding
+  end
+
+  def test_method
+    defined?(A) or DEFINE.call
+    assert_equal "#{self.class}::A", A.name
+
+    assert_equal binop_def(:f, :+),
+                 A.instance_method(:f).to_ast
+
+    assert_equal no_arg_def(:g, "A#g"),
+                 A.instance_method(:g).to_ast
+  end
+
+  def test_lambda
+    defined?(A) or DEFINE.call
+    assert_equal "#{self.class}::A", A.name
+
+    assert_equal binop_block(:lambda, :*),
+                 A::LAMBDA.to_ast
+  end
+end
+

data/test/redefine_method_test.rb

@@ -0,0 +1,83 @@
+require_relative 'main'
+
+class RedefineMethodTest < RegularTest
+  DEFINE_A = lambda do
+    class A
+      def f
+        "old A#f"
+      end
+      
+      PREVIOUS_Af = instance_method(:f)
+      remove_method :f
+      
+      def f(x, y)
+        x * y
+      end
+    end
+  end
+
+  def test_inclass_redef
+    DEFINE_A.call
+
+    assert_equal binop_def(:f, :*),
+                 A.instance_method(:f).to_ast
+
+    assert_equal no_arg_def(:f, "old A#f"),
+                 A::PREVIOUS_Af.to_ast
+  end
+
+  DEFINE_B = lambda do
+    class B
+      def f
+        "old B#f"
+      end
+    end
+  end
+
+  def test_dynamic_redef
+    DEFINE_B.call
+
+    assert_equal "old B#f", B.new.f
+    assert_equal no_arg_def(:f, "old B#f"), B.instance_method(:f).to_ast
+
+    B.class_eval do
+      remove_method :f
+      define_method :f do |x, y|
+        x - y
+      end
+    end
+
+    assert_equal 11, B.new.f(44, 33)
+
+    assert_equal binop_define_method(:f, :-),
+                 B.instance_method(:f).to_ast
+  end
+
+  DEFINE_C = lambda do
+    class C
+      def f
+        "old C#f"
+      end
+    end
+  end
+
+  def test_dynamic_redef_with_eval
+    DEFINE_C.call
+
+    assert_equal "old C#f", C.new.f
+
+    C.class_eval do
+      ast_eval %{
+        remove_method :f
+        define_method :f do |x, y|
+          x * y
+        end
+      }, binding
+    end
+
+    assert_equal 12, C.new.f(3, 4)
+
+    assert_equal binop_define_method(:f, :*),
+                 C.instance_method(:f).to_ast
+  end
+end

data/test/reload_test.rb

@@ -0,0 +1,105 @@
+require_relative 'main'
+
+class AAB_ReloadTest < BaseTest
+  include FileUtils
+
+  def test_reloading
+    raw_reload
+    require 'live_ast/ast_load'
+    noninvasive_ast_reload
+    require 'live_ast/replace_load'
+    ast_reload
+  end
+
+  def raw_reload
+    code_1 = %{
+      class AAB_ReloadTest::A
+        def f
+          "first A#f"
+        end
+      end
+    }
+  
+    code_2 = %{
+      class AAB_ReloadTest::A
+        def f
+          "second A#f"
+        end
+      end
+    }
+
+    temp_file code_1 do |file|
+      load file
+
+      LiveAST.ast(A.instance_method(:f))
+
+      write_file file, code_2
+      load file
+
+      # forced a raw-reload inconsistency -- verify bogus
+
+      assert_equal no_arg_def(:f, "first A#f"),
+                   LiveAST.ast(A.instance_method(:f))
+    end
+  end
+
+  def noninvasive_ast_reload
+    code_1 = %{
+      class AAB_ReloadTest::B
+        def f
+          "first B#f"
+        end
+      end
+    }
+
+    code_2 = %{
+      class AAB_ReloadTest::B
+        def f
+          "second B#f"
+        end
+      end
+    }
+
+    temp_file code_1 do |file|
+      load file
+    
+      LiveAST.ast(B.instance_method(:f))
+      
+      write_file file, code_2
+      ast_load file
+      
+      assert_equal no_arg_def(:f, "second B#f"),
+                   LiveAST.ast(B.instance_method(:f))
+    end
+  end
+
+  def ast_reload
+    code_1 = %{
+      class AAB_ReloadTest::C
+        def f
+          "first C#f"
+        end
+      end
+    }
+
+    code_2 = %{
+      class AAB_ReloadTest::C
+        def f
+          "second C#f"
+        end
+      end
+    }
+
+    temp_file code_1 do |file|
+      load file
+    
+      LiveAST.ast(C.instance_method(:f))
+
+      write_file file, code_2
+      load file
+
+      assert_equal no_arg_def(:f, "second C#f"),
+                   LiveAST.ast(C.instance_method(:f))
+    end
+  end
+end

data/test/replace_eval_test.rb

@@ -0,0 +1,405 @@
+require_relative 'main'
+
+class ZZY_ReplaceEvalTest < ReplaceEvalTest
+  RESULT = {}
+
+  def setup
+    RESULT.clear
+  end
+
+  DEFINE_A = lambda do
+    class A
+      eval %{
+        def f(x, y)
+          x**y
+        end
+      }
+    end
+  end
+
+  def test_a_def_method
+    DEFINE_A.call
+    assert_equal binop_def(:f, :**), A.instance_method(:f).to_ast
+  end
+
+  DEFINE_B = lambda do
+    eval %{
+      class B
+        def f(x, y)
+          x / y
+        end
+      end
+    }
+  end
+
+  def test_def_class
+    DEFINE_B.call
+    assert_equal "ZZY_ReplaceEvalTest::B", B.name
+    assert_equal binop_def(:f, :/), B.instance_method(:f).to_ast
+  end
+
+  def moo
+    a = 22
+    ignore(a)
+    binding
+  end
+
+  def test_binding_eval
+    assert_equal 22, moo.eval("a")
+    assert_equal 22, moo.eval("lambda { a }").call
+  end
+
+  DEFINE_P = lambda do
+    class P
+      eval %{
+        def f
+          @x = 33
+          RESULT[:old] = live_ast_original_eval("@x")
+          RESULT[:new] = eval("@x")
+        end
+      }
+    end
+  end
+
+  def test_const_lookup
+    DEFINE_P.call
+    P.new.f
+
+    assert_equal 33, RESULT[:old]
+    assert_equal 33, RESULT[:new]
+  end
+
+  def test_const_lookup_2
+    Class.new do
+      eval %{
+        def f
+          @x = 44
+          RESULT[:old] = live_ast_original_eval("@x")
+          RESULT[:new] = eval("@x")
+        end
+      }
+    end.new.f
+
+    assert_equal 44, RESULT[:old]
+    assert_equal 44, RESULT[:new]
+  end
+
+  DEFINE_QS = lambda do
+    class Q
+      class R
+        eval %{
+          def f
+            RESULT[:qr] = 55
+          end
+        }
+      end
+    end
+  
+    module S
+      class T
+        eval %{
+          def f
+            RESULT[:st] = 66
+          end
+        }
+      end
+    end
+  end
+  
+  def test_const_lookup_3
+    DEFINE_QS.call
+    Q::R.new.f
+    S::T.new.f
+    assert_equal 55, RESULT[:qr]
+    assert_equal 66, RESULT[:st]
+  end
+
+  def test_eval_arg_error
+    [[], (1..5).to_a].each do |args|
+      orig = assert_raises ArgumentError do
+        live_ast_original_eval(*args)
+      end
+      live = assert_raises ArgumentError do
+        eval(*args)
+      end
+      assert_equal orig.message, live.message
+    end
+  end
+
+  def test_singleton_eval_arg_error
+    [[], (1..5).to_a].each do |args|
+      orig = assert_raises ArgumentError do
+        Kernel.live_ast_original_singleton_eval(*args)
+      end
+      live = assert_raises ArgumentError do
+        Kernel.eval(*args)
+      end
+      assert_equal orig.message, live.message
+    end
+  end
+
+  def test_instance_eval_arg_error_no_block
+    [[], ('a'..'z').to_a].each do |args|
+      orig = assert_raises ArgumentError do
+        Object.new.live_ast_original_instance_eval(*args)
+      end
+      live = assert_raises ArgumentError do
+        Object.new.instance_eval(*args)
+      end
+      assert_equal orig.message, live.message
+    end
+
+    orig = assert_raises TypeError do
+      Object.new.live_ast_original_instance_eval(nil)
+    end
+    live = assert_raises TypeError do
+      Object.new.instance_eval(nil)
+    end
+    assert_equal orig.message, live.message
+
+    [[nil], [Object.new], [3], [4,3,2], (1..10).to_a].each do |args|
+      orig = assert_raises TypeError do
+        Object.new.live_ast_original_instance_eval(*args)
+      end
+      live = assert_raises TypeError do
+        Object.new.instance_eval(*args)
+      end
+      assert_equal orig.message, live.message
+    end
+  end
+
+  def test_instance_eval_arg_error_with_block
+    orig = assert_raises ArgumentError do
+      Object.new.live_ast_original_instance_eval(3,4,5) { }
+    end
+    live = assert_raises ArgumentError do
+      Object.new.instance_eval(3,4,5) { }
+    end
+    assert_equal orig.message, live.message
+  end
+
+  def test_instance_eval_block
+    orig = {}
+    orig.live_ast_original_instance_eval do
+      self[:x] = 33
+    end
+    assert_equal 33, orig[:x]
+
+    live = {}
+    live.instance_eval do
+      self[:x] = 44
+    end
+    assert_equal 44, live[:x]
+  end
+
+  def test_instance_eval_string
+    orig = {}
+    orig.live_ast_original_instance_eval %{
+      self[:x] = 33
+    }
+    assert_equal 33, orig[:x]
+
+    live = {}
+    live.instance_eval %{
+      self[:x] = 44
+    }
+    assert_equal 44, live[:x]
+  end
+
+  def test_instance_eval_binding
+    x = 33
+    orig = {}
+    orig.live_ast_original_instance_eval %{
+      self[:x] = x
+      self[:f] = lambda { "f" }
+    }
+    assert_equal x, orig[:x]
+
+    y = 44
+    live = {}
+    live.instance_eval %{
+      self[:y] = y
+      self[:g] = lambda { "g" }
+    }
+    assert_equal y, live[:y]
+    
+    assert_equal no_arg_block(:lambda, "g"), live[:g].to_ast
+  end
+
+  def test_module_eval_block
+    orig = Module.new
+    orig.live_ast_original_module_eval do
+      def f
+        "orig"
+      end
+    end
+    orig.instance_method(:f)
+
+    live = Module.new
+    live.module_eval do
+      def f
+        "live"
+      end
+    end
+    assert_equal no_arg_def(:f, "live"),
+                 live.instance_method(:f).to_ast
+  end
+
+  def test_module_eval_string
+    orig = Module.new
+    orig.live_ast_original_module_eval %{
+      def f
+        "orig"
+      end
+    }
+    orig.instance_method(:f)
+
+    live = Module.new
+    live.module_eval %{
+      def h
+        "live h"
+      end
+    }
+    assert_equal no_arg_def(:h, "live h"),
+                 live.instance_method(:h).to_ast
+  end
+
+  def test_module_eval_binding
+    x = 33
+    ignore(x)
+    orig = Class.new
+    orig.live_ast_original_module_eval %{
+      define_method :value do
+        x
+      end
+      define_method :f do
+        lambda { }
+      end
+    }
+    assert_equal 33, orig.new.value
+    assert orig.new.f.is_a?(Proc)
+
+    y = 44
+    ignore(y)
+    live = Class.new
+    live.module_eval %{
+      define_method :value do
+        y
+      end
+      define_method :g do
+        lambda { "g return" }
+      end
+    }
+    assert_equal 44, live.new.value
+    assert live.new.g.is_a?(Proc)
+
+    assert_equal no_arg_block(:lambda, "g return"),
+                 live.new.g.to_ast
+  end
+
+  def test_module_eval_file_line
+    klass = Module.new
+
+    orig =
+      klass.live_ast_original_module_eval("[__FILE__, __LINE__]", "test", 102)
+    live =
+      klass.module_eval("[__FILE__, __LINE__]", "test", 102)
+
+    unfixable do
+      assert_equal orig, live
+    end
+    
+    live.first.sub!(/#{Regexp.quote LiveAST::Linker::REVISION_TOKEN}.*\Z/, "")
+    assert_equal orig, live
+    assert_equal ["test", 102], live
+  end
+
+  def test_module_eval_to_str
+    file = MiniTest::Mock.new
+    file.expect(:to_str, "zebra.rb")
+    Class.new.module_eval("33 + 44", file)
+    file.verify
+  end
+
+  def test_eval_not_hosed
+    assert_equal 3, eval("1 + 2")
+    1.times do
+      assert_equal 3, eval("1 + 2")
+    end
+
+    assert_equal(3, eval(%{ eval("1 + 2") }))
+    1.times do
+      assert_equal(3, eval(%{ eval("1 + 2") }))
+    end
+
+    x = 5
+    eval %{
+      assert_equal(3, eval(%{ eval("1 + 2") }))
+      x = 6
+    }
+    assert_equal 6, x
+  end
+
+  def test_local_var_collision
+    args = 33
+    ignore(args)
+
+    assert_equal 33, live_ast_original_eval("args")
+    assert_equal 33, eval("args")
+
+    assert_equal 33, Kernel.live_ast_original_singleton_eval("args")
+    assert_equal 33, Kernel.eval("args")
+
+    assert_equal 33, binding.live_ast_original_binding_eval("args")
+    assert_equal 33, binding.eval("args")
+
+    assert_equal 33, Object.new.live_ast_original_instance_eval("args")
+    assert_equal 33, Object.new.instance_eval("args")
+
+    assert_equal 33, Class.new.live_ast_original_module_eval("args")
+    assert_equal 33, Class.new.module_eval("args")
+
+    assert_equal 33, Class.new.live_ast_original_instance_eval("args")
+    assert_equal 33, Class.new.instance_eval("args")
+  end
+
+  def test_location_without_binding
+    expected = ["(eval)", 2]
+
+    assert_equal expected, live_ast_original_eval("\n[__FILE__, __LINE__]")
+
+    unfixable do
+      assert_equal expected, eval("\n[__FILE__, __LINE__]")
+    end
+
+    file, line = eval("\n[__FILE__, __LINE__]")
+    file = LiveAST.strip_token file
+
+    assert_equal expected, [file, line]
+  end
+
+  DEFINE_BO_TEST = lambda do
+    class BasicObject
+      Kernel.eval("1 + 1")
+    end
+  end
+
+  def test_basic_object
+    ::BasicObject.new.instance_eval %{
+      t = 33
+      ::ZZY_ReplaceEvalTest::RESULT[:bo_test] = t + 44
+    }
+    assert_equal 77, RESULT[:bo_test]
+  end
+
+  class Z
+    def initialize
+      @t = 99
+    end
+  end
+
+  def test_instance_variables
+    assert_equal 99, Z.new.instance_eval{ @t }
+    assert_equal 99, Z.new.instance_eval("@t")
+  end
+end