mvz-live_ast 1.1.0

data/test/flush_cache_test.rb

@@ -0,0 +1,98 @@
+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/irb_test.rb

@@ -0,0 +1,25 @@
+require_relative 'main'
+
+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 test_irb
+    with_module(Object, :IRB) do
+      with_module(LiveAST, :IRBSpy) do
+        LiveAST::IRBSpy.class_eval do
+          def self.code_at(line)
+            "def f ; end"
+          end
+        end
+        LiveAST::Linker.fetch_from_cache("(irb)", 1)
+      end
+    end
+  end
+end

data/test/lambda_test.rb

@@ -0,0 +1,56 @@
+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_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

@@ -0,0 +1,78 @@
+require_relative 'main'
+
+class AAA_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
+    mkdir DATA_DIR, :verbose => false rescue nil
+    Dir.chdir(DATA_DIR) do
+      check_load
+      check_errors
+    end
+  end
+
+  def check_load
+    code_1 = %{
+      def hello
+        "password"
+      end
+    }
+
+    code_2 = %{
+      def goodbye
+        "bubbleboy"
+      end
+    }
+
+    temp_file code_1, "foo.rb" do |path|
+      Object.send(:remove_method, :hello) rescue nil
+      load "foo.rb"
+      assert_equal "password", hello
+      
+      write_file path, code_2
+      
+      Object.send(:remove_method, :goodbye) rescue nil
+      LiveAST.load "foo.rb"
+      assert_equal "bubbleboy", goodbye
+    end
+  ensure
+    Object.send(:remove_method, :hello) rescue nil
+    Object.send(:remove_method, :goodbye) rescue nil
+  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

data/test/load_test.rb

@@ -0,0 +1,123 @@
+require_relative 'main'
+require_relative '../devel/levitate'
+
+class AAA_LoadFileTest < BaseTest
+  class << self
+    attr_accessor :flag
+  end
+
+  def test_a_no_locals_created
+    code = %{
+      AAA_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, AAA_LoadFileTest.flag
+      
+      assert_raises NameError do
+        eval("x", TOPLEVEL_BINDING)
+      end
+
+      assert_equal 77, ::FOO
+    end
+  end
+
+  def test_b_no_locals_modified
+    code = %{
+      AAA_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, AAA_LoadFileTest.flag
+      
+      actual = eval("r", TOPLEVEL_BINDING)
+      assert_equal 66, actual
+    end
+  end
+  
+  def test_c_wrap
+    code = %{
+      AAA_LoadFileTest.flag = :code_c
+      ZOOM = 111
+    }
+
+    temp_file code do |file|
+      ret = LiveAST.load file, true
+      assert_equal true, ret
+      assert_equal :code_c, AAA_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 = %{
+      AAA_LoadFileTest.from_d
+    }
+    
+    temp_file code do |file|
+      LiveAST.load file
+      assert_equal :code_d, AAA_LoadFileTest.flag
+    end
+  end
+
+  def test_verbose_respected
+    lib = File.expand_path(File.dirname(__FILE__) + "/../lib")
+
+    [
+     # 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

@@ -0,0 +1,140 @@
+$LOAD_PATH.unshift File.expand_path(File.dirname(__FILE__) + '/../lib')
+
+# require first for stdlib_test
+require 'pp'
+require 'find'
+require 'fileutils'
+
+require 'minitest/unit'
+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::Unit::TestCase
+  def self.test_methods
+    default = super
+    onlies = default.select { |m| m =~ %r!__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
+    begin
+      yield
+      raise "claimed to be unfixable, but assertion succeeded"
+    rescue MiniTest::Assertion
+    end
+  end
+
+  def assert_nothing_raised
+    yield
+    assert_nil nil
+  rescue => 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
+    FileUtils.mkdir DATA_DIR unless File.directory? DATA_DIR
+
+    write_file path, code if code
+    begin
+      yield path
+    ensure
+      FileUtils.rm_f path
+      FileUtils.rmdir DATA_DIR rescue nil
+    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
+    begin
+      yield
+    rescue Exception => e
+      e.backtrace
+    end
+  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
+           if RUBY_ENGINE == "ruby"
+             raise "need: gem install boc"
+           end
+           false
+         end
+
+    unless ok
+      self.class.class_eval do
+        instance_methods(false).each do |m|
+          remove_method(m)
+          define_method(m) { }
+        end
+      end
+    end
+  end
+end