mvz-live_ast 1.3.0 → 2.1.0

data/test/error_test.rb

@@ -1,116 +0,0 @@
-require_relative 'main'
-
-class ErrorTest < RegularTest
-  def test_multiple_lambda_same_line
-    a = lambda {}; b = lambda {}
-    ignore(b)
-
-    assert_raises LiveAST::MultipleDefinitionsOnSameLineError do
-      a.to_ast
-    end
-  end
-
-  DEFINE_A = lambda do
-    class A
-      def f; end; def g; end
-    end
-  end
-
-  def test_multi_defs
-    DEFINE_A.call
-    assert_raises LiveAST::MultipleDefinitionsOnSameLineError do
-      A.instance_method(:f).to_ast
-    end
-  end
-
-  def test_ast_not_found
-    assert_raises LiveAST::ASTNotFoundError do
-      File.method(:open).to_ast
-    end
-  end
-
-  def test_arg_error_too_many
-    orig = assert_raises ArgumentError do
-      eval("s", binding, "f", 99, nil)
-    end
-
-    live = assert_raises ArgumentError do
-      ast_eval("s", binding, "f", 99, nil)
-    end
-
-    assert_equal orig.message.sub("1..4", "2..4"), live.message
-  end
-
-  def test_bad_args
-    [99, Object.new, File].each do |bad|
-      orig = assert_raises TypeError do
-        eval(bad, binding)
-      end
-      live = assert_raises TypeError do
-        ast_eval(bad, binding)
-      end
-      assert_equal orig.message, live.message
-
-      orig = assert_raises TypeError do
-        eval("3 + 4", binding, bad)
-      end
-      live = assert_raises TypeError do
-        ast_eval("3 + 4", binding, bad)
-      end
-      assert_equal orig.message, live.message
-    end
-  end
-
-  def test_raw_eval
-    f = eval("lambda { }")
-    assert_raises LiveAST::RawEvalError do
-      f.to_ast
-    end
-  end
-
-  def test_reload_with_raw_eval_1
-    ast_eval("lambda { }", binding)
-    eval("lambda { }")
-  end
-
-  def test_reload_with_raw_eval_2
-    c = ast_eval %{
-      Class.new do
-        def f
-        end
-      end
-    }, binding
-    c.module_eval do
-      eval %{
-        remove_method :f
-        def f(x, y)
-          x + y
-        end
-      }
-      nil
-    end
-
-    assert_raises LiveAST::RawEvalError do
-      c.instance_method(:f).to_ast
-    end
-  end
-
-  def test_bad_binding
-    orig = assert_raises TypeError do
-      eval("", "bogus")
-    end
-
-    live = assert_raises TypeError do
-      ast_eval("", "bogus")
-    end
-
-    assert_equal orig.message, live.message
-  end
-
-  def test_shenanigans
-    error = assert_raises RuntimeError do
-      LiveAST.load "foo.rb|ast@4"
-    end
-    assert_match(/revision token/, error.message)
-  end
-end

data/test/eval_test.rb

@@ -1,269 +0,0 @@
-require_relative 'main'
-
-class EvalTest < RegularTest
-  DEFINE_A = lambda do
-    class A
-      ast_eval %{
-        def f(x, y)
-          x + y
-        end
-      }, binding
-    end
-  end
-
-  def test_eval_method
-    DEFINE_A.call
-    assert_equal "#{self.class}::A", A.name
-    assert_equal A, A.instance_method(:f).owner
-
-    assert_equal binop_def(:f, :+),
-                 A.instance_method(:f).to_ast
-
-    assert_equal binop_def(:f, :+),
-                 A.new.method(:f).to_ast
-  end
-
-  DEFINE_B = lambda do
-    ast_eval %{
-      class B
-        def f(x, y)
-          x * y
-        end
-      end
-    }, binding
-  end
-
-  def test_eval_class
-    DEFINE_B.call
-    assert_equal "#{self.class}::B", B.name
-    assert_equal B, B.instance_method(:f).owner
-
-    assert_equal binop_def(:f, :*),
-                 B.instance_method(:f).to_ast
-
-    assert_equal binop_def(:f, :*),
-                 B.new.method(:f).to_ast
-  end
-
-  def test_eval_method_anon
-    klass = Class.new do
-      ast_eval %{
-        def f(x, y)
-          x - y
-        end
-      }, binding
-    end
-
-    assert_nil klass.name
-    assert_equal klass, klass.instance_method(:f).owner
-
-    assert_equal binop_def(:f, :-),
-                 klass.instance_method(:f).to_ast
-
-    assert_equal binop_def(:f, :-),
-                 klass.new.method(:f).to_ast
-  end
-
-  def test_eval_class_anon
-    klass = ast_eval %{
-      Class.new do
-        def f(x, y)
-          x / y
-        end
-      end
-    }, binding
-
-    assert_nil klass.name
-    assert_equal klass, klass.instance_method(:f).owner
-
-    assert_equal binop_def(:f, :/),
-                 klass.instance_method(:f).to_ast
-
-    assert_equal binop_def(:f, :/),
-                 klass.new.method(:f).to_ast
-  end
-
-  DEFINE_C = lambda do
-    class C
-      ast_eval %{
-        define_method :g do |x, y|
-          x + y
-        end
-      }, binding
-    end
-  end
-
-  def test_eval_method_dynamic
-    DEFINE_C.call
-    assert_equal "#{self.class}::C", C.name
-    assert_equal C, C.instance_method(:g).owner
-
-    assert_equal binop_define_method(:g, :+),
-                 C.instance_method(:g).to_ast
-
-    assert_equal binop_define_method(:g, :+),
-                 C.new.method(:g).to_ast
-  end
-
-  DEFINE_D = lambda do
-    ast_eval %{
-      class D
-        define_method :g do |x, y|
-          x * y
-        end
-      end
-    }, binding
-  end
-
-  def test_eval_class_dynamic
-    DEFINE_D.call
-    assert_equal "#{self.class}::D", D.name
-    assert_equal D, D.instance_method(:g).owner
-
-    assert_equal binop_define_method(:g, :*),
-                 D.instance_method(:g).to_ast
-
-    assert_equal binop_define_method(:g, :*),
-                 D.new.method(:g).to_ast
-  end
-
-  def test_eval_method_anon_dynamic
-    klass = Class.new do
-      ast_eval %{
-        define_method :g do |x, y|
-          x - y
-        end
-      }, binding
-    end
-
-    assert_nil klass.name
-    assert_equal klass, klass.instance_method(:g).owner
-
-    assert_equal binop_define_method(:g, :-),
-                 klass.instance_method(:g).to_ast
-
-    assert_equal binop_define_method(:g, :-),
-                 klass.new.method(:g).to_ast
-  end
-
-  def test_eval_class_anon_dynamic
-    klass = ast_eval %{
-      Class.new do
-        define_method :g do |x, y|
-          x / y
-        end
-      end
-    }, binding
-
-    assert_nil klass.name
-    assert_equal klass, klass.instance_method(:g).owner
-
-    assert_equal binop_define_method(:g, :/),
-                 klass.instance_method(:g).to_ast
-
-    assert_equal binop_define_method(:g, :/),
-                 klass.new.method(:g).to_ast
-  end
-
-  DEFINE_GH = lambda do
-    ast_eval %{
-      class G
-        def f
-          "G#f"
-        end
-      end
-
-      class H
-        def g
-          "H#g"
-        end
-      end
-    }, binding
-  end
-
-  def test_reuse_string
-    DEFINE_GH.call
-    assert_equal "#{self.class}::G", G.name
-    assert_equal "#{self.class}::H", H.name
-
-    assert_equal no_arg_def(:f, "G#f"),
-                 G.instance_method(:f).to_ast
-
-    assert_equal no_arg_def(:f, "G#f"),
-                 G.new.method(:f).to_ast
-
-    assert_equal no_arg_def(:g, "H#g"),
-                 H.instance_method(:g).to_ast
-
-    assert_equal no_arg_def(:g, "H#g"),
-                 H.new.method(:g).to_ast
-  end
-
-  def test_module_eval
-    klass = Class.new
-    klass.module_eval do
-      ast_eval %{
-        def f
-          "z"
-        end
-      }, binding
-    end
-
-    assert_equal klass, klass.instance_method(:f).owner
-
-    assert_equal no_arg_def(:f, "z"),
-                 klass.instance_method(:f).to_ast
-
-    assert_equal no_arg_def(:f, "z"),
-                 klass.new.method(:f).to_ast
-  end
-
-  def test_singleton_class
-    obj = Object.new
-    obj.singleton_class.module_eval do
-      ast_eval %{
-        def f
-          "singleton"
-        end
-      }, binding
-    end
-
-    assert_equal no_arg_def(:f, "singleton"),
-                 obj.method(:f).to_ast
-  end
-
-  def test_proc_in_eval
-    a = ast_eval %{ proc { |x, y| x + y } }, binding
-
-    assert_equal binop_block(:proc, :+), a.to_ast
-  end
-
-  def test_proc_new_in_eval
-    a = ast_eval %{ Proc.new { |x, y| x * y } }, binding
-
-    assert_equal binop_proc_new(:*), a.to_ast
-  end
-
-  def test_method_block_in_eval
-    a = ast_eval %{ return_block { |x, y| x - y } }, binding
-
-    assert_equal binop_block(:return_block, :-), a.to_ast
-  end
-
-  def test_lambda_in_eval
-    a = ast_eval %{ lambda { |x, y| x / y } }, binding
-
-    assert_equal binop_block(:lambda, :/), a.to_ast
-
-    # sanity check
-    assert_not_equal binop_block(:lambda, :+), a.to_ast
-  end
-
-  # from rubyspec
-  def test_to_str_on_file
-    file = MiniTest::Mock.new
-    file.expect(:to_str, "zebra.rb")
-    ast_eval "33 + 44", binding, file
-    file.verify
-  end
-end

data/test/flush_cache_test.rb

@@ -1,98 +0,0 @@
-require_relative 'main'
-
-# test for flushing side-effects: unsort this TestCase from other
-# TestCases.
-
-define_unsorted_test_case "FlushCacheTest", RegularTest do
-  def test_cache
-    # testing global state of cache -- must be sequential
-    uncached_method_from_require
-    uncached_method_from_eval
-    cached_method_from_eval
-    lost_method_from_require
-    flush_lambda
-  end
-
-  def uncached_method_from_require
-    klass = Class.new do
-      def f; end
-      def g; end
-    end
-
-    LiveAST.flush_cache
-
-    #
-    # file never made it into the cache; unaffected by flush
-    #
-    assert_nothing_raised do
-      klass.instance_method(:g).to_ast
-    end
-  end
-
-  def uncached_method_from_eval
-    klass = Class.new do
-      ast_eval %{
-        def f ; end
-        def g ; end
-      }, binding
-    end
-
-    LiveAST.flush_cache
-
-    assert_raises LiveAST::ASTNotFoundError do
-      klass.instance_method(:g).to_ast
-    end
-  end
-
-  def cached_method_from_eval
-    klass = Class.new do
-      ast_eval %{
-        def f ; end
-        def g ; end
-      }, binding
-    end
-
-    f_ast = klass.instance_method(:f).to_ast
-
-    LiveAST.flush_cache
-
-    assert_equal f_ast.object_id,
-                 klass.instance_method(:f).to_ast.object_id
-
-    assert_raises LiveAST::ASTNotFoundError do
-      klass.instance_method(:g).to_ast
-    end
-  end
-
-  def lost_method_from_require
-    klass = Class.new do
-      def f; end
-      def g; end
-    end
-
-    # check that previous flushing did not cause side effect
-    assert_nothing_raised do
-      klass.instance_method(:f).to_ast
-    end
-  end
-
-  def flush_lambda
-    a, b = ast_eval %{
-      [
-        lambda { "aaa" },
-        lambda { "bbb" },
-      ]
-    }, binding
-
-    a_ast = a.to_ast
-    assert_equal no_arg_block(:lambda, "aaa"), a_ast
-
-    LiveAST.flush_cache
-
-    assert_equal a_ast.object_id, a.to_ast.object_id
-
-    assert_raises LiveAST::ASTNotFoundError do
-      b.to_ast
-    end
-  end
-end

data/test/full/ast_reload_test.rb

@@ -1,39 +0,0 @@
-require 'main'
-
-class ASTReloadTest < ReplaceEvalTest
-  include FileUtils
-
-  def test_reloading
-    ast_reload
-  end
-
-  def ast_reload
-    code1 = %{
-      class ASTReloadTest::C
-        def f
-          "first C#f"
-        end
-      end
-    }
-
-    code2 = %{
-      class ASTReloadTest::C
-        def f
-          "second C#f"
-        end
-      end
-    }
-
-    temp_file code1 do |file|
-      load file
-
-      LiveAST.ast(C.instance_method(:f))
-
-      write_file file, code2
-      load file
-
-      assert_equal no_arg_def(:f, "second C#f"),
-                   LiveAST.ast(C.instance_method(:f))
-    end
-  end
-end