live_ast 0.2.0

data/test/covert_define_method_test.rb

@@ -0,0 +1,23 @@
+require_relative 'shared/main'
+
+class CovertDefineMethodTest < RegularTest
+  DEFINE = lambda do
+    class A
+      def A.my_def(*args, &block)
+        define_method(*args, &block)
+      end
+      
+      my_def :h do |x, y|
+        x + y
+      end
+    end
+  end
+
+  def test_covert_define_method
+    DEFINE.call
+    assert_equal 77, A.new.h(33, 44)
+
+    assert_equal binop_covert_define_method(:h, :+, :my_def),
+                 A.instance_method(:h).to_ast
+  end
+end

data/test/def_test.rb

@@ -0,0 +1,35 @@
+require_relative 'shared/main'
+
+class DefTest < RegularTest
+  class A
+    def f
+      "A#f"
+    end
+  end
+
+  def test_def_unbound_method_a
+    expected = no_arg_def(:f, "A#f")
+    assert_equal expected, A.instance_method(:f).to_ast
+  end
+
+  def test_def_method_a
+    expected = no_arg_def(:f, "A#f")
+    assert_equal expected, A.new.method(:f).to_ast
+  end
+
+  class B
+    def f(x, y)
+      x + y
+    end
+  end
+
+  def test_def_unbound_method_b
+    expected = binop_def(:f, :+)
+    assert_equal expected, B.instance_method(:f).to_ast
+  end
+
+  def test_def_instance_method_b
+    expected = binop_def(:f, :+)
+    assert_equal expected, B.new.method(:f).to_ast
+  end
+end

data/test/define_method_test.rb

@@ -0,0 +1,41 @@
+require_relative 'shared/main'
+
+class DefineMethodTest < RegularTest
+  DEFINE = lambda do
+    class A
+      {
+        :f => :+,
+        :g => :*,
+        :h => :-,
+      }.each_pair do |name, op|
+        case op
+        when :+
+          define_method name do |x, y|
+            x + y
+          end
+        when :*
+          define_method name do |x, y|
+            x * y
+          end
+        when :-
+          define_method name do |x, y|
+            x - y
+          end
+        end
+      end
+    end
+  end
+
+  def test_define_method
+    DEFINE.call
+
+    assert_equal binop_define_method_with_var(:name, :+),
+                 A.instance_method(:f).to_ast
+
+    assert_equal binop_define_method_with_var(:name, :*),
+                 A.instance_method(:g).to_ast
+
+    assert_equal binop_define_method_with_var(:name, :-),
+                 A.instance_method(:h).to_ast
+  end
+end

data/test/define_singleton_method_test.rb

@@ -0,0 +1,15 @@
+require_relative 'shared/main'
+
+class DefineSingletonMethodTest < RegularTest
+  def test_define_singleton_method
+    a = Object.new
+    a.define_singleton_method :f do |x, y|
+      x + y
+    end
+
+    assert_equal 77, a.f(33, 44)
+
+    assert_equal binop_define_singleton_method(:f, :+, :a),
+                 a.singleton_class.instance_method(:f).to_ast
+  end
+end

data/test/encoding_test/bad.rb

@@ -0,0 +1 @@
+# encoding: feynman-diagram

data/test/encoding_test/cp932.rb

@@ -0,0 +1,6 @@
+# -*- coding: cp932 -*-
+module EncodingTest
+  def cp932_string
+    "�傫�Ȕ��Ƃ˂��B"
+  end
+end

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/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/utf8.rb

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

data/test/encoding_test.rb

@@ -0,0 +1,51 @@
+require_relative 'shared/main'
+
+require_relative 'encoding_test/default.rb'
+require_relative 'encoding_test/usascii.rb'
+require_relative 'encoding_test/utf8.rb'
+require_relative 'encoding_test/cp932.rb'
+require_relative 'encoding_test/eucjp.rb'
+require_relative 'encoding_test/koi8.rb'
+require_relative 'encoding_test/koi8_shebang.rb'
+
+class AllEncodingTest < RegularTest
+  include EncodingTest
+
+  %w[
+
+    default US-ASCII
+    usascii US-ASCII
+    utf8 UTF-8
+    cp932 Windows-31J
+    eucjp EUC-JP
+    koi8 KOI8-R
+    koi8_shebang KOI8-R
+
+  ].each_slice(2) do |abbr, name|
+    define_method "test_#{abbr}" do
+      str = send("#{abbr}_string")
+      assert_equal name, str.encoding.to_s
+
+      ast = EncodingTest.instance_method("#{abbr}_string").to_ast
+      assert_equal name, no_arg_def_return(ast).encoding.to_s
+      
+      LiveAST.load "./test/encoding_test/#{abbr}.rb"
+      
+      ast = EncodingTest.instance_method("#{abbr}_string").to_ast
+      assert_equal name, no_arg_def_return(ast).encoding.to_s
+    end
+  end
+
+  def test_bad
+    orig = assert_raise ArgumentError do
+      require "./test/encoding_test/bad.rb"
+    end
+    live = assert_raise ArgumentError do
+      LiveAST.load "./test/encoding_test/bad.rb"
+    end
+    # inconsistent punctuation from Ruby
+    re = %r!\Aunknown encoding name\s*[-:]\s*feynman-diagram\Z!
+    assert_match re, orig.message
+    assert_match re, live.message
+  end
+end

data/test/error_test.rb

@@ -0,0 +1,115 @@
+require_relative 'shared/main'
+
+class ErrorTest < RegularTest
+  def test_multiple_lambda_same_line
+    a = lambda { } ; b = lambda { }
+    
+    assert_raise 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_raise LiveAST::MultipleDefinitionsOnSameLineError do
+      A.instance_method(:f).to_ast
+    end
+  end
+
+  def test_ast_not_found
+    assert_raise LiveAST::NoSourceError 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 'shared/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

data/test/flush_cache_test.rb

@@ -0,0 +1,98 @@
+require_relative 'shared/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_raise LiveAST::FlushedError 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_raise LiveAST::FlushedError 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_raise LiveAST::FlushedError do
+      b.to_ast
+    end
+  end
+end