mvz-live_ast 2.0.0 → 2.1.0

data/test/full/replace_eval_test.rb

@@ -1,433 +0,0 @@
-# frozen_string_literal: true
-
-require "main"
-
-class FullReplaceEvalTest < 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 "FullReplaceEvalTest::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_two
-    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_three
-    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 ArgumentError, TypeError do
-        Object.new.live_ast_original_instance_eval(*args)
-      end
-      live = assert_raises ArgumentError, TypeError do
-        Object.new.instance_eval(*args)
-      end
-      assert_equal orig.message, live.message
-      assert_equal orig.class, live.class
-    end
-  end
-
-  describe "instance_eval argument errors" do
-    before do
-      require "live_ast/full"
-    end
-
-    let(:orig) {
-      assert_raises(ArgumentError, TypeError) do
-        Object.new.live_ast_original_instance_eval(*args)
-      end
-    }
-    let(:live) {
-      assert_raises(ArgumentError, TypeError) do
-        Object.new.instance_eval(*args)
-      end
-    }
-
-    describe "when the second argument is nil" do
-      let(:args) { ["1", nil] }
-      it "raises the same error as the original" do
-        assert_equal orig.message, live.message
-        assert_equal orig.class, live.class
-      end
-    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) { nil }
-    end
-    live = assert_raises ArgumentError do
-      Object.new.instance_eval(3, 4, 5) { nil }
-    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
-      ::FullReplaceEvalTest::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

data/test/irb_test.rb

@@ -1,43 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "main"
-require "live_ast/irb_spy"
-
-class IRBTest < RegularTest
-  def with_module(parent, child)
-    parent.const_set child, Module.new
-    begin
-      yield
-    ensure
-      parent.send :remove_const, child
-    end
-  end
-
-  def setup
-    LiveAST::IRBSpy.history = [
-      nil,
-      "class Foo; def bar; 'bar'; end; end",
-      "class Bar",
-      "  def foo",
-      "    'foo'",
-      "  end",
-      "end"
-    ]
-  end
-
-  def test_single_line
-    with_module(Object, :IRB) do
-      expected = no_arg_def(:bar, "bar")
-      result = LiveAST::Linker.fetch_from_cache("(irb)", 1)
-      assert_equal expected, result
-    end
-  end
-
-  def test_multiple_lines
-    with_module(Object, :IRB) do
-      expected = no_arg_def(:foo, "foo")
-      result = LiveAST::Linker.fetch_from_cache("(irb)", 3)
-      assert_equal expected, result
-    end
-  end
-end

data/test/lambda_test.rb

@@ -1,65 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "main"
-
-class LambdaTest < RegularTest
-  def test_block_braces_multiline
-    block = return_block { |x, y|
-      x + y
-    }
-
-    expected = binop_block(:return_block, :+)
-    assert_equal expected, block.to_ast
-  end
-
-  def test_block_do_end_multiline
-    block = return_block do |x, y|
-      x * y
-    end
-
-    expected = binop_block(:return_block, :*)
-    assert_equal expected, block.to_ast
-  end
-
-  def test_lambda
-    a = lambda { |x, y| x - y }
-
-    expected = binop_block(:lambda, :-)
-    assert_equal expected, a.to_ast
-  end
-
-  def test_stabby_lambda
-    a = ->(x, y) { x - y }
-
-    expected = binop_lambda(:-)
-    assert_equal expected, a.to_ast
-  end
-
-  def test_proc
-    a = proc { |x, y| x / y }
-
-    expected = binop_block(:proc, :/)
-    assert_equal expected, a.to_ast
-  end
-
-  def test_proc_new
-    a = Proc.new { |x, y| x + y }
-
-    expected = binop_proc_new(:+)
-    assert_equal expected, a.to_ast
-  end
-
-  def test_block_braces_one_line
-    block = return_block { |x, y| x * y }
-
-    expected = binop_block(:return_block, :*)
-    assert_equal expected, block.to_ast
-  end
-
-  def test_block_do_end_one_line
-    block = return_block do |x, y| x - y end
-
-    expected = binop_block(:return_block, :-)
-    assert_equal expected, block.to_ast
-  end
-end

data/test/load_path_test.rb

@@ -1,77 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "main"
-
-class LoadPathTest < BaseTest
-  include FileUtils
-
-  def test_load_path
-    $LOAD_PATH.unshift DATA_DIR
-    begin
-      check_load
-      check_errors
-      temp_file nil, "foo.rb" do
-        Dir.chdir(DATA_DIR) do
-          compare_load_errors("/foo.rb")
-        end
-      end
-    ensure
-      $LOAD_PATH.shift
-    end
-  end
-
-  def test_chdir
-    Dir.chdir(DATA_DIR) do
-      check_load
-      check_errors
-    end
-  end
-
-  def check_load
-    code1 = %{
-      def hello
-        "password"
-      end
-    }
-
-    code2 = %{
-      def goodbye
-        "bubbleboy"
-      end
-    }
-
-    temp_file code1, "foo.rb" do |path|
-      load "foo.rb"
-      assert_equal "password", hello
-
-      write_file path, code2
-
-      LiveAST.load "foo.rb"
-      assert_equal "bubbleboy", goodbye
-    end
-  ensure
-    Object.send(:remove_method, :hello)
-    Object.send(:remove_method, :goodbye)
-  end
-
-  def compare_load_errors(file)
-    error = assert_raises LoadError do
-      LiveAST.load file
-    end
-    assert_equal "cannot load such file -- #{file}", error.message
-  end
-
-  def check_errors
-    temp_file "# do nothing", "foo.rb" do |_path|
-      [
-        "foo",
-        "",
-        "/usr",
-        ".",
-        ".."
-      ].each do |file|
-        compare_load_errors(file)
-      end
-    end
-  end
-end