mvz-live_ast 1.3.0 → 2.1.0

data/test/main.rb

@@ -1,129 +0,0 @@
-$LOAD_PATH.unshift File.expand_path(File.dirname(__FILE__) + '/../lib')
-
-# 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 => ex
-    raise MiniTest::Assertion,
-      exception_details(ex, "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(File.dirname(__FILE__) + "/data")
-
-  def self.stdlib_has_source?
-    RUBY_ENGINE != "jruby"
-  end
-
-  def temp_file(code, basename = nil)
-    basename ||= ('a'..'z').to_a.shuffle.join + ".rb"
-    path = 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 binding_of_caller" 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) {}
-      end
-    end
-  end
-end

data/test/nested_test.rb

@@ -1,29 +0,0 @@
-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,14 +0,0 @@
-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,51 +0,0 @@
-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,83 +0,0 @@
-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,25 +0,0 @@
-require_relative 'main'
-require_relative '../devel/levitate'
-
-class RubygemsTest < RegularTest
-  def test_rubygems
-    lib = File.expand_path(File.dirname(__FILE__) + "/../lib")
-    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,37 +0,0 @@
-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,25 +0,0 @@
-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,13 +0,0 @@
-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,43 +0,0 @@
-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,11 +0,0 @@
-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,11 +0,0 @@
-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

data/test/to_ruby/to_ruby_test.rb

@@ -1,99 +0,0 @@
-require 'main'
-
-if LiveAST.parser::Test.respond_to?(:unparser_matches_ruby2ruby?) &&
-   LiveAST.parser::Test.unparser_matches_ruby2ruby?
-  class ToRubyTest < RegularTest
-    def setup
-      super
-      require 'live_ast/to_ruby'
-    end
-
-    def test_lambda_0
-      src = %{lambda { "moo" }}
-      dst = ast_eval(src, binding).to_ruby
-      assert_equal src, dst
-    end
-
-    def test_lambda_1
-      src = %{lambda { |x| (x ** 2) }}
-      dst = ast_eval(src, binding).to_ruby
-      assert_equal src, dst
-    end
-
-    def test_lambda_2
-      src = %{lambda { |x, y| (x + y) }}
-      dst = ast_eval(src, binding).to_ruby
-      assert_equal src, dst
-    end
-
-    def test_proc_0
-      src = %{proc { "moo" }}
-      dst = ast_eval(src, binding).to_ruby
-      assert_equal src, dst
-    end
-
-    def test_proc_1
-      src = %{proc { |x| (x ** 2) }}
-      dst = ast_eval(src, binding).to_ruby
-      assert_equal src, dst
-    end
-
-    def test_proc_2
-      src = %{proc { |x, y| (x * y) }}
-      dst = ast_eval(src, binding).to_ruby
-      assert_equal src, dst
-    end
-
-    def test_block_0
-      src = %{return_block { "moo" }}
-      dst = ast_eval(src, binding).to_ruby
-      assert_equal src, dst
-    end
-
-    def test_block_1
-      src = %{return_block { |x| (x ** 2) }}
-      dst = ast_eval(src, binding).to_ruby
-      assert_equal src, dst
-    end
-
-    def test_block_2
-      src = %{return_block { |x, y| (x - y) }}
-      dst = ast_eval(src, binding).to_ruby
-      assert_equal src, dst
-    end
-
-    def test_method_0
-      src = %{def f\n  "moo"\nend}
-      dst = Class.new do
-        ast_eval(src, binding)
-      end.instance_method(:f).to_ruby
-      assert_equal src, dst
-    end
-
-    def test_method_1
-      src = %{def f(x)\n  (x ** 2)\nend}
-      dst = Class.new do
-        ast_eval(src, binding)
-      end.instance_method(:f).to_ruby
-      assert_equal src, dst
-    end
-
-    def test_method_2
-      src = %{def f(x, y)\n  (x / y)\nend}
-      dst = Class.new do
-        ast_eval(src, binding)
-      end.instance_method(:f).to_ruby
-      assert_equal src, dst
-    end
-
-    def test_to_ast_after_to_ruby
-      src = %{lambda { "moo" }}
-      expected_ast = ast_eval(src, binding).to_ast
-
-      lmb = ast_eval(src, binding)
-      lmb.to_ruby
-
-      assert_equal expected_ast, lmb.to_ast
-    end
-  end
-end