mvz-live_ast 1.1.0

data/test/encoding_test/default.rb

@@ -0,0 +1,5 @@
+module EncodingTest
+  def default_string
+    "Cats and large boxes."  # google translate
+  end
+end

data/test/encoding_test/eucjp.rb

@@ -0,0 +1,6 @@
+# encoding: euc-jp -*-
+module EncodingTest
+  def eucjp_string
+    "�礭��Ȣ�Ȥͤ���"
+  end
+end

data/test/encoding_test/koi8.rb

@@ -0,0 +1,6 @@
+# -*- coding: koi8-r -*-
+module EncodingTest
+  def koi8_string
+    "� ���������� ������� ���������� �� 20 ��������"
+  end
+end

data/test/encoding_test/koi8_shebang.rb

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+# -*- coding: koi8-r -*-
+module EncodingTest
+  def koi8_shebang_string
+    "� ���������� ������� ���������� �� 20 ��������"
+  end
+end

data/test/encoding_test/koi8_with_utf8bom.rb

@@ -0,0 +1,6 @@
+# -*- coding: koi8-r -*-
+module EncodingTest
+  def koi8_with_utf8bom_string
+    "� ���������� ������� ���������� �� 20 ��������"
+  end
+end

data/test/encoding_test/usascii.rb

@@ -0,0 +1,6 @@
+# encoding: us-ascii
+module EncodingTest
+  def usascii_string
+    "Cats and large boxes."  # google translate
+  end
+end

data/test/encoding_test/usascii_with_utf8bom.rb

@@ -0,0 +1,6 @@
+# encoding: us-ascii
+module EncodingTest
+  def usascii_with_utf8bom_string
+    "Cats and large boxes."
+  end
+end

data/test/encoding_test/utf8.rb

@@ -0,0 +1,6 @@
+# -*- coding: utf-8 -*-
+module EncodingTest
+  def utf8_string
+    "大きな箱とねこ。"
+  end
+end

data/test/encoding_test/utf8bom.rb

@@ -0,0 +1,6 @@
+# -*- coding: utf-8 -*-
+module EncodingTest
+  def utf8bom_string
+    "大きな箱とねこ。"
+  end
+end

data/test/encoding_test/utf8bom_only.rb

@@ -0,0 +1,5 @@
+module EncodingTest
+  def utf8bom_only_string
+    "大きな箱とねこ。"
+  end
+end

data/test/encoding_test/utf8dos.rb

@@ -0,0 +1,6 @@
+# -*- coding: utf-8-dos -*-
+module EncodingTest
+  def utf8dos_string
+    "大きな箱とねこ。"
+  end
+end

data/test/encoding_test/utf8mac.rb

@@ -0,0 +1,6 @@
+# -*- coding: utf-8-mac -*-
+module EncodingTest
+  def utf8mac_string
+    "大きな箱とねこ。"
+  end
+end

data/test/encoding_test/utf8mac_alt.rb

@@ -0,0 +1,6 @@
+# -*- coding: utf8-mac -*-
+module EncodingTest
+  def utf8mac_alt_string
+    "大きな箱とねこ。"
+  end
+end

data/test/encoding_test/utf8unix.rb

@@ -0,0 +1,6 @@
+# -*- coding: utf-8-unix -*-
+module EncodingTest
+  def utf8unix_string
+    "大きな箱とねこ。"
+  end
+end

data/test/error_test.rb

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

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