mvz-live_ast 2.0.0 → 2.1.0

data/test/load_test.rb

@@ -1,125 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "main"
-require_relative "../devel/levitate"
-
-class LoadFileTest < BaseTest
-  class << self
-    attr_accessor :flag
-  end
-
-  def test_a_no_locals_created
-    code = %{
-      LoadFileTest.flag = :code_a
-      FOO = 77
-      x = 33
-      y = 99
-    }
-
-    temp_file code do |file|
-      ret = LiveAST.load file
-      assert_equal true, ret
-      assert_equal :code_a, LoadFileTest.flag
-
-      assert_raises NameError do
-        eval("x", TOPLEVEL_BINDING)
-      end
-
-      assert_equal 77, ::FOO
-    end
-  end
-
-  def test_b_no_locals_modified
-    code = %{
-      LoadFileTest.flag = :code_b
-      r = 55
-    }
-
-    temp_file code do |file|
-      eval("r = 66", TOPLEVEL_BINDING)
-
-      ret = LiveAST.load file
-      assert_equal true, ret
-      assert_equal :code_b, LoadFileTest.flag
-
-      actual = eval("r", TOPLEVEL_BINDING)
-      assert_equal 66, actual
-    end
-  end
-
-  def test_c_wrap
-    code = %{
-      LoadFileTest.flag = :code_c
-      ZOOM = 111
-    }
-
-    temp_file code do |file|
-      ret = LiveAST.load file, true
-      assert_equal true, ret
-      assert_equal :code_c, LoadFileTest.flag
-
-      assert_raises NameError do
-        ZOOM
-      end
-    end
-  end
-
-  def self.from_d
-    self.flag = :code_d
-  end
-
-  def test_d_empty_locals_list
-    code = %{
-      LoadFileTest.from_d
-    }
-
-    temp_file code do |file|
-      LiveAST.load file
-      assert_equal :code_d, LoadFileTest.flag
-    end
-  end
-
-  def test_verbose_respected
-    lib = File.expand_path("../lib", File.dirname(__FILE__))
-
-    [
-      # respects a loaded file setting $VERBOSE = true
-      [
-        "false",
-        "true",
-        lambda { |file|
-          Levitate.run file
-        }
-      ],
-
-      # unfixable: does not respect a loaded file setting $VERBOSE = nil
-      [
-        "true",
-        "false",
-        lambda { |file|
-          unfixable do
-            assert_nothing_raised do
-              Levitate.run file
-            end
-          end
-        }
-      ]
-    ].each do |main_value, loaded_value, action|
-      loaded_code = %{
-        $VERBOSE = #{loaded_value}
-      }
-
-      temp_file loaded_code do |loaded_file|
-        main_code = %{
-          $LOAD_PATH.unshift '#{lib}'
-          require 'live_ast/base'
-          toplevel_local = 444
-          $VERBOSE = #{main_value}
-          LiveAST.load '#{loaded_file}'
-          $VERBOSE == #{loaded_value} or exit(1)
-        }
-        temp_file main_code, &action
-      end
-    end
-  end
-end

data/test/main.rb

@@ -1,134 +0,0 @@
-# frozen_string_literal: true
-
-$LOAD_PATH.unshift File.expand_path("../lib", File.dirname(__FILE__))
-
-# require first for stdlib_test
-require "pp"
-require "find"
-require "fileutils"
-
-require "minitest/mock"
-require "minitest/autorun"
-
-$VERBOSE = true
-
-require "live_ast/base"
-
-def define_unsorted_test_case(name, superclass, &block)
-  klass = Class.new superclass, &block
-  letter = ("A".."Z").to_a[rand(26)]
-  Object.const_set "#{letter}#{name}", klass
-end
-
-class JLMiniTest < MiniTest::Test
-  def self.test_methods
-    default = super
-    onlies = default.select { |m| m =~ /__only\Z/ }
-    if onlies.empty?
-      default
-    else
-      puts "\nNOTE: running ONLY *__only tests for #{self}"
-      onlies
-    end
-  end
-
-  def delim(char)
-    "\n#{char * 72}\n"
-  end
-
-  def mu_pp(obj)
-    +"" <<
-      delim("_") <<
-      obj.pretty_inspect.chomp <<
-      delim("=")
-  end
-
-  def unfixable
-    yield
-    raise "claimed to be unfixable, but assertion succeeded"
-  rescue MiniTest::Assertion
-  end
-
-  def assert_nothing_raised
-    yield
-    assert_nil nil
-  rescue StandardError => e
-    raise MiniTest::Assertion,
-          exception_details(e, "Expected nothing raised, but got:")
-  end
-
-  %w(
-    empty equal in_delta in_epsilon includes instance_of
-    kind_of match nil operator respond_to same
-  ).each { |name|
-    alias_method "assert_not_#{name}", "refute_#{name}"
-  }
-end
-
-class BaseTest < JLMiniTest
-  include LiveAST.parser::Test
-
-  DATA_DIR = File.expand_path("data", File.dirname(__FILE__))
-
-  def self.stdlib_has_source?
-    RUBY_ENGINE != "jruby"
-  end
-
-  def temp_file(code, basename = nil)
-    basename ||= ("a".."z").to_a.shuffle.join + ".rb"
-    path = File.join(DATA_DIR, basename)
-
-    write_file path, code if code
-    begin
-      yield path
-    ensure
-      FileUtils.rm_f path
-    end
-  end
-
-  def write_file(file, contents)
-    File.open(file, "w") { |f| f.print contents }
-  end
-
-  def return_block(&block)
-    block
-  end
-
-  def exception_backtrace
-    yield
-  rescue Exception => e
-    e.backtrace
-  end
-
-  def ignore(*_args); end
-end
-
-class RegularTest < BaseTest
-  def setup
-    super
-    require "live_ast"
-  end
-end
-
-class ReplaceEvalTest < BaseTest
-  def initialize(*args)
-    super
-    ok = begin
-           require "live_ast/full"
-           true
-         rescue LoadError
-           raise "need: gem install bindings" if RUBY_ENGINE == "ruby"
-
-           false
-         end
-
-    return if ok
-
-    self.class.class_eval do
-      instance_methods(false).each do |m|
-        remove_method(m)
-        define_method(m) { nil }
-      end
-    end
-  end
-end

data/test/nested_test.rb

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-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/readme_test.rb

@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "main"
-require_relative "../devel/levitate"
-
-if RUBY_ENGINE != "jruby" # 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

@@ -1,53 +0,0 @@
-# frozen_string_literal: true
-
-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

@@ -1,85 +0,0 @@
-# frozen_string_literal: true
-
-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/rubygems_test.rb

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "main"
-require_relative "../devel/levitate"
-
-class RubygemsTest < RegularTest
-  def test_rubygems
-    lib = File.expand_path("../lib", File.dirname(__FILE__))
-    extra_req =
-      if defined?(LiveASTRipper) && LiveAST.parser == LiveASTRipper
-        %{require 'live_ast_ripper'}
-      else
-        ""
-      end
-    result = Levitate.run_code_and_capture %{
-      $LOAD_PATH.unshift '#{lib}'
-      #{extra_req}
-      require 'live_ast/full'
-      LiveAST.parser::Test
-      f = eval %{
-        lambda { 'abc' }
-      }
-      p f.to_ast
-    }
-    assert_equal no_arg_block(:lambda, "abc").to_s, result.chomp
-  end
-end

data/test/rubyspec_test.rb

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "main"
-require_relative "../devel/levitate"
-
-#
-# Tests against rubyspec branch which discards '|ast@' tokens
-#
-if ENV["LIVE_AST_RUBYSPEC_HOME"]
-  class RubySpecTest < RegularTest
-    FILES = [
-      "core/basicobject/instance_eval_spec.rb",
-      "core/binding/eval_spec.rb",
-      "core/kernel/eval_spec.rb",
-      "core/kernel/instance_eval_spec.rb",
-      "core/module/class_eval_spec.rb",
-      "core/module/module_eval_spec.rb"
-    ].freeze
-
-    def setup
-      super
-      puts "\n==== rubyspec"
-    end
-
-    FILES.each do |file|
-      mname = "test_" + file.tr("/", "_").chop!.chop!.chop!
-      define_method mname do
-        Dir.chdir ENV["LIVE_AST_RUBYSPEC_HOME"] do
-          cmd =
-            ["mspec", "-t", Levitate.ruby_bin] +
-            (["-T"] * Levitate.ruby_opts.size).zip(Levitate.ruby_opts).flatten +
-            [file]
-
-          assert system(*cmd)
-        end
-      end
-    end
-  end
-end

data/test/singleton_test.rb

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "main"
-
-class SingletonTest < RegularTest
-  class A
-    def self.f
-      "A.f"
-    end
-  end
-
-  def test_self_dot
-    expected = singleton_no_arg_def(:f, "A.f")
-    assert_equal expected, A.method(:f).to_ast
-  end
-
-  class B
-    def B.f(x, y)
-      x + y
-    end
-  end
-
-  def test_name_dot
-    expected = singleton_binop_def(:B, :f, :+)
-    assert_equal expected, B.method(:f).to_ast
-  end
-end

data/test/stdlib_test.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "main"
-
-class StdlibTest < RegularTest
-  if stdlib_has_source?
-    def test_pp
-      assert_not_nil method(:pp).to_ast
-    end
-
-    def test_find
-      assert_not_nil Find.method(:find).to_ast
-    end
-  end
-end

data/test/thread_test.rb

@@ -1,45 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "main"
-
-require "thread"
-
-class ThreadTest < RegularTest
-  def test_threads
-    klass = nil
-    mutex = Mutex.new
-    stop = false
-    results = []
-    num_threads = 50
-
-    workers = (0...num_threads).map {
-      Thread.new {
-        until stop
-          if klass
-            found = klass.instance_method(:f).to_ast
-            mutex.synchronize {
-              results << found
-            }
-            break
-          end
-        end
-      }
-    }
-
-    klass = Class.new do
-      def f
-        "anon#f"
-      end
-    end
-
-    sleep(0.2)
-    stop = true
-
-    workers.each(&:join)
-
-    assert_equal num_threads, results.size
-    results.each { |result|
-      assert_equal no_arg_def(:f, "anon#f"), result
-    }
-  end
-end

data/test/to_ast/to_ast_feature_test.rb

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-
-require "main"
-
-require "live_ast/to_ast"
-
-class ToASTFeatureTest < BaseTest
-  def test_require
-    [Method, UnboundMethod, Proc].each { |obj|
-      assert obj.instance_methods.include?(:to_ast)
-    }
-  end
-end

data/test/to_ruby/to_ruby_feature_test.rb

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-
-require "main"
-
-require "live_ast/to_ruby"
-
-class ToRubyFeatureTest < BaseTest
-  def test_defines_to_ruby
-    [Method, UnboundMethod, Proc].each { |obj|
-      assert obj.instance_methods.include?(:to_ruby)
-    }
-  end
-end