live_ast 0.2.0

data/test/lambda_test.rb

@@ -0,0 +1,56 @@
+require_relative 'shared/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,84 @@
+require_relative 'shared/main'
+
+class AAA_LoadPathTest < BaseTest
+  include FileUtils
+  
+  def test_load_path
+    $LOAD_PATH.unshift DATA_DIR
+    begin
+      check_load
+      check_errors
+      temp_file "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 "foo.rb" do |path|
+      write_file(path, code_1)
+
+      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)
+    orig = assert_raise LoadError do
+      load file
+    end
+    live = assert_raise LoadError do
+      LiveAST.load file
+    end
+    assert_equal orig.message, live.message
+  end
+
+  def check_errors
+    temp_file "foo.rb" do |path|
+      touch path, :verbose => false
+      [
+       "foo",
+       "",
+       "/usr",
+       ".",
+       "..",
+      ].each do |file|
+        compare_load_errors(file)
+      end
+    end
+  end
+end

data/test/load_test.rb

@@ -0,0 +1,85 @@
+require_relative 'shared/main'
+
+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 do |file|
+      write_file file, code
+
+      ret = LiveAST.load file
+      assert_equal true, ret
+      assert_equal :code_a, AAA_LoadFileTest.flag
+      
+      assert_raise 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 do |file|
+      eval("r = 66", TOPLEVEL_BINDING)
+      
+      write_file file, code
+      
+      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 do |file|
+      write_file file, code
+      
+      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 do |file|
+      write_file file, code
+      LiveAST.load file
+      assert_equal :code_d, AAA_LoadFileTest.flag
+    end
+  end
+end

data/test/noninvasive_test.rb

@@ -0,0 +1,51 @@
+require_relative 'shared/main'
+
+class AAA_NoninvasiveTest < BaseTest
+  def test_no_clutter
+    [Method, UnboundMethod, Proc].each do |klass|
+      assert !klass.instance_methods.include?(:to_ast)
+      assert !klass.instance_methods.include?(:to_ruby)
+    end
+    
+    assert !respond_to?(:ast_eval)
+    assert !Kernel.respond_to?(:ast_eval)
+    assert !respond_to?(:ast_load)
+    assert !Kernel.respond_to?(:ast_load)
+  end
+
+  DEFINE_A = lambda do
+    class A
+      def f
+        "A#f"
+      end
+    end
+  end
+
+  def test_method
+    DEFINE_A.call
+
+    expected = no_arg_def(:f, "A#f")
+    assert_equal expected, LiveAST.ast(A.instance_method(:f))
+    assert_equal expected, LiveAST.ast(A.new.method(:f))
+  end
+
+  def test_lambda
+    a = lambda { |x, y| x ** y }
+
+    assert_equal binop_block(:lambda, :**), LiveAST.ast(a)
+  end
+
+  def test_ast_eval
+    code = %{ lambda { |x, y| x / y } }
+    
+    expected = binop_block(:lambda, :/)
+    result = LiveAST.ast(LiveAST.eval(code, binding))
+    assert_equal expected, result
+  end
+
+  def test_bogus
+    assert_raises TypeError do
+      LiveAST.ast(99)
+    end
+  end
+end

data/test/readme_test.rb

@@ -0,0 +1,11 @@
+require_relative 'shared/main'
+require_relative '../devel/jumpstart'
+
+sections = [
+  "Synopsis",
+  "Loading Source",
+  "Noninvasive Interface",
+  "+to_ruby+",
+]
+
+Jumpstart.doc_to_test("README.rdoc", *sections)

data/test/recursive_eval_test.rb

@@ -0,0 +1,52 @@
+require_relative 'shared/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

@@ -0,0 +1,83 @@
+require_relative 'shared/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/reload_test.rb

@@ -0,0 +1,108 @@
+require_relative 'shared/main'
+
+class AAB_ReloadTest < BaseTest
+  include FileUtils
+
+  def test_reloading
+    raw_reload
+    require 'live_ast/ast_load'
+    noninvasive_ast_reload
+    require 'live_ast/replace_load'
+    ast_reload
+  end
+
+  def raw_reload
+    code_1 = %{
+      class AAB_ReloadTest::A
+        def f
+          "first A#f"
+        end
+      end
+    }
+  
+    code_2 = %{
+      class AAB_ReloadTest::A
+        def f
+          "second A#f"
+        end
+      end
+    }
+
+    temp_file do |file|
+      write_file file, code_1
+      load file
+
+      LiveAST.ast(A.instance_method(:f))
+
+      write_file file, code_2
+      load file
+
+      # forced a raw-reload inconsistency -- verify bogus
+
+      assert_equal no_arg_def(:f, "first A#f"),
+                   LiveAST.ast(A.instance_method(:f))
+    end
+  end
+
+  def noninvasive_ast_reload
+    code_1 = %{
+      class AAB_ReloadTest::B
+        def f
+          "first B#f"
+        end
+      end
+    }
+
+    code_2 = %{
+      class AAB_ReloadTest::B
+        def f
+          "second B#f"
+        end
+      end
+    }
+
+    temp_file do |file|
+      write_file file, code_1
+      load file
+    
+      LiveAST.ast(B.instance_method(:f))
+      
+      write_file file, code_2
+      ast_load file
+      
+      assert_equal no_arg_def(:f, "second B#f"),
+                   LiveAST.ast(B.instance_method(:f))
+    end
+  end
+
+  def ast_reload
+    code_1 = %{
+      class AAB_ReloadTest::C
+        def f
+          "first C#f"
+        end
+      end
+    }
+
+    code_2 = %{
+      class AAB_ReloadTest::C
+        def f
+          "second C#f"
+        end
+      end
+    }
+
+    temp_file do |file|
+      write_file file, code_1
+      load file
+    
+      LiveAST.ast(C.instance_method(:f))
+
+      write_file file, code_2
+      load file
+
+      assert_equal no_arg_def(:f, "second C#f"),
+                   LiveAST.ast(C.instance_method(:f))
+    end
+  end
+end

data/test/shared/ast_generators.rb

@@ -0,0 +1,124 @@
+module ASTGenerators
+  #
+  # no_arg_def(:f, "A#f") returns the ast of
+  #
+  #   def f
+  #     "A#f"
+  #   end
+  #
+  def no_arg_def(name, ret)
+    s(:defn, name, s(:args), s(:scope, s(:block, s(:str, ret))))
+  end
+
+  #
+  # no_arg_def_return(no_arg_def(:f, "A#f")) == "A#f"
+  #
+  def no_arg_def_return(ast)
+    ast[3][1][1][1]
+  end
+
+  #
+  # binop_def(:f, :+) returns the ast of
+  #
+  #   def f(x, y)
+  #     x + y
+  #   end
+  #
+  def binop_def(name, op)
+    s(:defn,
+      name,
+      s(:args, :x, :y),
+      s(:scope,
+        s(:block, s(:call, s(:lvar, :x), op, s(:arglist, s(:lvar, :y))))))
+  end
+
+  #
+  # binop_define_method(:f, :*) returns the ast of
+  #
+  #   define_method :f do |x, y|
+  #     x * y
+  #   end
+  #
+  def binop_define_method(name, op)
+    s(:iter,
+      s(:call, nil, :define_method, s(:arglist, s(:lit, name))),
+      s(:masgn, s(:array, s(:lasgn, :x), s(:lasgn, :y))),
+      s(:call, s(:lvar, :x), op, s(:arglist, s(:lvar, :y))))
+  end
+
+  #
+  # binop_covert_define_method(:f, :-, :my_def) returns the ast of
+  #
+  #   my_def :f do |x, y|
+  #     x - y
+  #   end
+  #
+  def binop_covert_define_method(name, op, covert_name)
+    s(:iter,
+      s(:call, nil, covert_name, s(:arglist, s(:lit, name))),
+      s(:masgn, s(:array, s(:lasgn, :x), s(:lasgn, :y))),
+      s(:call, s(:lvar, :x), op, s(:arglist, s(:lvar, :y))))
+  end
+
+  #
+  # binop_define_method_with_var(:method_name, :/) returns the ast of
+  #
+  #   define_method method_name do |x, y|
+  #     x / y
+  #   end
+  #
+  def binop_define_method_with_var(name, op)
+    s(:iter,
+      s(:call, nil, :define_method, s(:arglist, s(:lvar, name))),
+      s(:masgn, s(:array, s(:lasgn, :x), s(:lasgn, :y))),
+      s(:call, s(:lvar, :x), op, s(:arglist, s(:lvar, :y))))
+  end
+
+  #
+  # binop_define_singleton_method(:f, :+, :a) returns the ast of
+  #
+  #   a.define_singleton_method :f do |x, y|
+  #     x + y
+  #   end
+  #
+  def binop_define_singleton_method(name, op, receiver)
+    s(:iter,
+      s(:call, s(:lvar, receiver), :define_singleton_method,
+        s(:arglist, s(:lit, name))),
+      s(:masgn, s(:array, s(:lasgn, :x), s(:lasgn, :y))),
+      s(:call, s(:lvar, :x), op, s(:arglist, s(:lvar, :y))))
+  end
+  
+  #
+  # no_arg_block(:foo, "bar") returns the ast of
+  #
+  #   foo { "bar" }
+  #
+  def no_arg_block(name, ret)
+    s(:iter, s(:call, nil, name, s(:arglist)), nil, s(:str, ret))
+  end
+  
+  #
+  # binop_block(:foo, :+) returns the ast of
+  #
+  #   foo { |x, y| x + y }
+  #
+  def binop_block(name, op, receiver = nil, args = [])
+    s(:iter,
+      s(:call, receiver, name, s(:arglist, *args)),
+      s(:masgn, s(:array, s(:lasgn, :x), s(:lasgn, :y))),
+      s(:call, s(:lvar, :x), op, s(:arglist, s(:lvar, :y))))
+  end
+
+  #
+  # binop_proc_new(:*) returns the ast of
+  #
+  #   Proc.new { |x, y| x * y }
+  #
+  def binop_proc_new(op)
+    s(:iter,
+      s(:call, s(:const, :Proc), :new, s(:arglist)),
+      s(:masgn, s(:array, s(:lasgn, :x), s(:lasgn, :y))),
+      s(:call, s(:lvar, :x), op, s(:arglist, s(:lvar, :y))))
+  end
+end