nodewrap 0.5.0

data/test/node_samples.rb

@@ -0,0 +1,122 @@
+Common_Node_Samples = {
+  :method      => "",
+  :fbody       => "",
+  # cfunc not dumpable
+  :ifunc       => "",
+  :scope       => "",
+  :block       => "",
+  :if          => "if true then 1 end",
+  :case        => "case 1 when 1 then true end",
+  :when        => "case 1 when 1 then true end",
+  :opt_n       => "",
+  :while       => "a = 0; while a != 1; a += 1; end",
+  :until       => "a = 0; until a == 1; a += 1; end",
+  :iter        => "loop { break }",
+  :for         => "a = 0; for i in 1..42; a += 1; end; a",
+  :break       => "a = 24; for i in 1..42; break if i == 24; a += 1; end; a",
+  :next        => "[1].each { next }",
+  :redo        => "a = false; [1].each { if not a; a = true; redo; end }",
+  :retry       => "a = true; begin; raise 'foo' if a; rescue; a = false; retry; end",
+  :begin       => "begin; rescue; end",
+  :rescue      => "begin; raise 'foo'; rescue; end",
+  :resbody     => "begin; raise 'foo'; rescue; end",
+  :ensure      => "begin; ensure; 10; end",
+  :and         => "true and false",
+  :or          => "if 1 or 2 then 3; end",
+  :not         => "not false",
+  :masgn       => "a, b, c = 4, 5, 6",
+  :lasgn       => "x = 1",
+  :dasgn       => "",
+  :dasgn_curr  => "",
+  :gasgn       => "$a = 1",
+  :iasgn       => "@a = 1",
+  :cdecl       => "",
+  :op_asgn1    => "{}[10] = 1",
+  :op_asgn2    => "{}.default = 1",
+  :op_asgn_and => "",
+  :op_asgn_or  => "",
+  :call        => "$stdout.sync",
+  :fcall       => "", # see iter
+  :vcall       => "",
+  :array       => "[1, 2, 3]",
+  :zarray      => "[]",
+  :hash        => "{ 1 => 2 }",
+  :lvar        => "",
+  :dvar        => "",
+  :gvar        => "$a == 1",
+  :ivar        => "@a == 42", # must be diff from iasgn
+  :const       => "",
+  :cvar        => "@@a == 42",
+  :cvar2       => "",
+  :nth_ref     => "$1 == nil",
+  :back_ref    => "$` == nil",
+  :match       => "",
+  :match2      => "",
+  :match3      => "",
+  :lit         => "17",
+  :str         => "\"foo\"",
+  :dstr        => "\"#{8}\"",
+  :xstr        => "`ls` if false",
+  :dxstr       => "`\#{foo}` if false",
+  :evstr       => "",
+  :dregx       => "/\#{42}/",
+  :dregx_i     => "/\#{42}/i", # same node type as dregx
+  :dregx_once  => "/\#{42}/o",
+  :args        => "",
+  :argscat     => "",
+  :argspush    => "''[0,*[1]] = 'foo'",
+  :restargs    => "",
+  :block_arg   => "", # def foo(&block)
+  :block_pass  => "",
+  :defn        => "",
+  :defs        => "",
+  :alias       => "",
+  :valias      => "",
+  :undef       => "",
+  :class       => "",
+  :module      => "",
+  :sclass      => "class << self; end",
+  :colon2      => "Object::Kernel",
+  :colon3      => "::Object",
+  :cref        => "",
+  :dot2        => "1..2",
+  :dot3        => "2...3",
+  :flip2       => "if 'foo' =~ /foo/ .. /bar/; end", # TODO
+  :flip3       => "if 'foo' =~ /foo/ ... /bar/; end", # TODO
+  :attrset     => "",
+  :self        => "self.nil?",
+  :nil         => "nil",
+  :true        => "true",
+  :false       => "false",
+  :defined     => "a = 1; defined?(a)",
+  :newline     => "\n",
+  :postexe     => "", # END { }
+  :alloca      => "",
+  :dmethod     => "",
+  :bmethod     => "",
+  :memo        => "",
+  :attrasgn    => "{}.default = 42",
+  # last is just a placeholder
+
+  :crash1      => "self.class.ancestors.include?(Object)",
+  :crash2      => "Object === self",
+}
+
+Method_Node_Samples = Common_Node_Samples.dup.update({
+  :cvasgn      => "@@a = 42", #TODO: not sure which of these is the decl and which is the asgn
+  :cvdecl      => "@@a = 42",
+  :super       => "super()",
+  :zsuper      => "super",
+  :return      => "",
+  :yield       => "yield",
+})
+
+Proc_Node_Samples = Common_Node_Samples.dup.update({
+  :cvasgn      => "",
+  :cvdecl      => "",
+  :super       => "", # can't call super from proc
+  :zsuper      => "", # can't call super from proc
+  :return      => "", # can't return from proc
+  :yield       => "",
+})
+

data/test/test.rb

@@ -0,0 +1,39 @@
+require 'nodewrap'
+
+def foo; Object; end
+
+m = method(:foo)
+n = m.body
+d = Marshal.dump(n)
+n2 = Marshal.load(d)
+
+c = Class.new
+c.class_eval { add_method :foo, n2, Noex::PUBLIC }
+
+obj2 = c.new
+
+# puts method(:foo).body.body.disasm
+# p method(:foo).body.body.to_a
+# 
+# puts c.method(:foo).body.body.disasm
+# p c.method(:foo).body.body.to_a
+# 
+# i = method(:foo).body.body
+# puts VM::InstructionSequence.load(i.to_a).disasm
+# p VM::InstructionSequence.load(i.to_a).to_a
+
+p obj2.foo
+
+# obj2.method(:foo).body.body.eval
+
+# require 'nodewrap'
+# 
+# i = VM::InstructionSequence.compile('Object')
+# s = Marshal.dump(i)
+# i2 = Marshal.load(s)
+# 
+# c = Class.new
+# c.class_eval { add_method :foo, i2, Noex::PUBLIC }
+# o = c.new
+# p o.foo
+

data/test/test2.rb

@@ -0,0 +1,7 @@
+$stdout.sync = true
+is = VM::InstructionSequence.compile('1 + 1')
+puts is.disasm
+a = is.to_a
+is2 = VM::InstructionSequence.load(a)
+puts is2.disasm
+

data/test/test3.rb

@@ -0,0 +1,5 @@
+i = VM::InstructionSequence.new('for a in []; end')
+puts i.disasm
+# a = i.to_a
+# i2 = VM::InstructionSequence.load(a)
+# puts i2.disasm

data/test/test4.rb

@@ -0,0 +1,5 @@
+i = VM::InstructionSequence.new('a, b, c = 4, 5, 6')
+# puts i.disasm
+# a = i.to_a
+# i2 = VM::InstructionSequence.load(a)
+# puts i2.disasm

data/test/test_as_code.rb

@@ -0,0 +1,249 @@
+require 'test/unit'
+require 'test/unit/ui/console/testrunner'
+require 'timeout'
+
+dir = File.dirname(__FILE__)
+$:.unshift(dir) if not $:.include?(dir)
+$:.unshift("#{dir}/../lib") if not $:.include?("#{dir}/../lib")
+$:.unshift("#{dir}/../ext") if not $:.include?("#{dir}/../ext")
+
+require 'nodewrap'
+require 'as_code'
+
+require "expression_samples"
+
+$stdout.sync = true
+$stderr.sync = true
+
+class TC_As_Code < Test::Unit::TestCase
+  MAJOR = Config::CONFIG['MAJOR'].to_i
+  MINOR = Config::CONFIG['MINOR'].to_i
+  TEENY = Config::CONFIG['TEENY'].to_i
+  RUBY_VERSION_CODE = MAJOR * 100 + MINOR * 10 + TEENY
+
+  extend Test::Unit::Assertions
+
+  # Some of the samples use this
+  def foo(*a, &b)
+    return b.call(1, 2) if b
+    return a
+  end
+
+  EXPRESSION_SAMPLES.each do |name, code|
+    p = proc {
+      p_orig = eval("proc { #{code} }")
+      code_new = p_orig.body.as_code
+      # p code, code_new
+      p_new = eval("proc { #{code_new} }")
+      result_orig = result_new = nil
+      exc_orig = exc_new = nil
+      timeout(1) { begin; result_orig = p_orig.call; rescue; exc_orig = $!; end }
+      timeout(1) { begin; result_new = p_new.call; rescue; exc_new = $!; end }
+      assert_equal(exc_orig.class, exc_new.class)
+      if exc_orig and exc_new then
+        assert_equal(exc_orig.message, exc_new.message)
+      end
+      assert_equal(result_orig, result_new)
+    }
+    define_method "test_#{name}", p
+  end
+
+  def initialize(test_method_name)
+    # TODO: This seems to be the only way to get tests defined with #
+    # define_method to run on 1.8.1 and earlier.
+    @method_name = test_method_name
+    @test_passed = true
+  end
+
+  def method_no_args
+    42
+  end
+
+  def test_method_no_args_as_code
+    m = method(:method_no_args)
+    assert_equal "def method_no_args()\n  42\nend", m.as_code
+  end
+
+  def method_one_arg(a)
+    42
+  end
+
+  def test_method_one_arg_as_code
+    m = method(:method_one_arg)
+    assert_equal "def method_one_arg(a)\n  42\nend", m.as_code
+  end
+
+  def method_two_args(a, b)
+    42
+  end
+
+  def test_method_two_args_as_code
+    m = method(:method_two_args)
+    assert_equal "def method_two_args(a, b)\n  42\nend", m.as_code
+  end
+
+  def method_rest_arg(*rest)
+    42
+  end
+
+  def test_method_rest_arg_as_code
+    m = method(:method_rest_arg)
+    assert_equal "def method_rest_arg(*rest)\n  42\nend", m.as_code
+  end
+
+  def method_block_arg(&block)
+    42
+  end
+
+  def test_method_block_arg_as_code
+    m = method(:method_block_arg)
+    assert_equal "def method_block_arg(&block)\n  42\nend", m.as_code
+  end
+
+  def method_rest_and_block_arg(*rest, &block)
+    42
+  end
+
+  def test_method_rest_and_block_arg_as_code
+    m = method(:method_rest_and_block_arg)
+    assert_equal "def method_rest_and_block_arg(*rest, &block)\n  42\nend", m.as_code
+  end
+
+  def method_two_args_and_rest_and_block_arg(a, b, *rest, &block)
+    42
+  end
+
+  def test_method_two_args_and_rest_and_block_arg_as_code
+    m = method(:method_two_args_and_rest_and_block_arg)
+    assert_equal "def method_two_args_and_rest_and_block_arg(a, b, *rest, &block)\n  42\nend", m.as_code
+  end
+
+  def method_with_body(a, b)
+    a + b
+  end
+
+  def test_method_with_body_as_code
+    m = method(:method_with_body)
+    assert_equal "def method_with_body(a, b)\n  a + b\nend", m.as_code
+  end
+
+  def method_begin_ensure_as_code(a, b, *rest, &block)
+    begin
+      if not a and not b then
+        raise "Need more input!"
+      end
+      return a + b
+    ensure
+      puts "In ensure block"
+    end
+  end
+
+  def test_method_begin_ensure_as_code
+    m = method(:method_begin_ensure_as_code)
+    if RUBY_VERSION_CODE >= 190 then
+      ret = ''
+    else
+      ret = 'return '
+    end
+
+    assert_equal <<-END.chomp, m.as_code(3)
+      def method_begin_ensure_as_code(a, b, *rest, &block)
+        begin
+          (raise("Need more input!")) if (not a and not b)
+          #{ret}a + b
+        ensure
+          puts("In ensure block")
+        end
+      end
+    END
+  end
+
+  def test_proc_no_args_as_code
+    p = proc { }
+    assert_equal "proc do\nend", p.as_code
+  end
+
+  def test_proc_empty_args_as_code
+    if not defined?(VM) then
+      # indistinguishable from proc { } on YARV
+      p = proc { || }
+      assert_equal "proc do ||\nend", p.as_code
+    end
+  end
+
+  def test_proc_one_arg_as_code
+    p = proc { |a| }
+    assert_equal "proc do |a|\nend", p.as_code
+  end
+
+  def test_proc_one_array_arg_as_expression
+    p = proc { |a,| }
+    assert_equal "proc do |a,|\nend", p.as_code
+  end
+
+  def test_proc_two_args_as_code
+    p = proc { |a, b| }
+    assert_equal "proc do |a, b|\nend", p.as_code
+  end
+
+  def test_proc_rest_arg_as_code
+    p = proc { |*rest| }
+    assert_equal "proc do |*rest|\nend", p.as_code
+  end
+
+  def test_proc_two_args_and_rest_arg_as_code
+    p = proc { |a, b, *rest| }
+    assert_equal "proc do |a, b, *rest|\nend", p.as_code
+  end
+
+  def test_proc_with_body_as_code
+    p = proc { |a, b| a + b }
+    assert_equal "proc do |a, b|\n  a + b\nend", p.as_code
+  end
+
+  def setup
+    @foo = 42
+  end
+
+  # 1.7 and later
+  def foo(*args)
+    return args
+  end
+
+  def remove_foo
+    self.class.remove_foo
+  end
+
+  # 1.6
+  def self.foo(*args)
+    return args
+  end
+
+  def self.remove_foo
+    self.class_eval { remove_const(:FOO) if const_defined?(:FOO) }
+  end
+
+  @@foo = 10
+
+  FOO = 57
+end
+
+if __FILE__ == $0 then
+  if Test::Unit.const_defined?(:AutoRunner) then
+    exit Test::Unit::AutoRunner.run
+  else
+    if ARGV.empty? then
+      suite = TC_As_Code.suite
+    else
+      suite = Test::Unit::TestSuite.new('TC_As_Code')
+      TC_As_Code.suite.tests.each do |test|
+        ARGV.each do |arg|
+          suite << test if /#{arg}/ =~ test.name
+        end
+      end
+    end
+    result = Test::Unit::UI::Console::TestRunner.run(suite)
+    exit(result.error_count + result.failure_count)
+  end
+end
+

data/test/test_as_expression.rb

@@ -0,0 +1,222 @@
+require 'test/unit'
+require 'test/unit/ui/console/testrunner'
+require 'timeout'
+
+dir = File.dirname(__FILE__)
+$:.unshift(dir) if not $:.include?(dir)
+$:.unshift("#{dir}/../lib") if not $:.include?("#{dir}/../lib")
+$:.unshift("#{dir}/../ext") if not $:.include?("#{dir}/../ext")
+
+require 'nodewrap'
+require 'as_expression'
+
+require "expression_samples"
+
+$stdout.sync = true
+$stderr.sync = true
+
+class TC_As_Expression < Test::Unit::TestCase
+  extend Test::Unit::Assertions
+
+  # Some of the samples use this
+  def foo(*a, &b)
+    return b.call(1, 2) if b
+    return a
+  end
+
+  EXPRESSION_SAMPLES.each do |name, code|
+    p = proc {
+      p_orig = eval("proc { #{code} }")
+      code_new = p_orig.body.as_expression
+      # p code, code_new
+      p_new = eval("proc { #{code_new} }")
+      result_orig = result_new = nil
+      exc_orig = exc_new = nil
+      timeout(1) { begin; result_orig = p_orig.call; rescue; exc_orig = $!; end }
+      timeout(1) { begin; result_new = p_new.call; rescue; exc_new = $!; end }
+      assert_equal(result_orig, result_new)
+      assert_equal(exc_orig.class, exc_new.class)
+      if exc_orig and exc_new then
+        assert_equal(exc_orig.message, exc_new.message)
+      end
+    }
+    define_method "test_#{name}", p
+  end
+
+  def initialize(test_method_name)
+    # TODO: This seems to be the only way to get tests defined with #
+    # define_method to run on 1.8.1 and earlier.
+    @method_name = test_method_name
+    @test_passed = true
+  end
+
+  def method_no_args
+    42
+  end
+
+  def test_method_no_args_as_expression
+    m = method(:method_no_args)
+    assert_equal 'def method_no_args(); 42; end', m.as_expression
+  end
+
+  def method_one_arg(a)
+    42
+  end
+
+  def test_method_one_arg_as_expression
+    m = method(:method_one_arg)
+    assert_equal 'def method_one_arg(a); 42; end', m.as_expression
+  end
+
+  def method_two_args(a, b)
+    42
+  end
+
+  def test_method_two_args_as_expression
+    m = method(:method_two_args)
+    assert_equal 'def method_two_args(a, b); 42; end', m.as_expression
+  end
+
+  def method_rest_arg(*rest)
+    42
+  end
+
+  def test_method_rest_arg_as_expression
+    m = method(:method_rest_arg)
+    assert_equal 'def method_rest_arg(*rest); 42; end', m.as_expression
+  end
+
+  def method_block_arg(&block)
+    42
+  end
+
+  def test_method_block_arg_as_expression
+    m = method(:method_block_arg)
+    assert_equal 'def method_block_arg(&block); 42; end', m.as_expression
+  end
+
+  def method_rest_and_block_arg(*rest, &block)
+    42
+  end
+
+  def test_method_rest_and_block_arg_as_expression
+    m = method(:method_rest_and_block_arg)
+    assert_equal 'def method_rest_and_block_arg(*rest, &block); 42; end', m.as_expression
+  end
+
+  def method_two_args_and_rest_and_block_arg(a, b, *rest, &block)
+    42
+  end
+
+  def test_method_two_args_and_rest_and_block_arg_as_expression
+    m = method(:method_two_args_and_rest_and_block_arg)
+    assert_equal 'def method_two_args_and_rest_and_block_arg(a, b, *rest, &block); 42; end', m.as_expression
+  end
+
+  def method_two_default_args(a = 1, b = 2)
+    42
+  end
+
+  def test_method_two_default_args_as_expression
+    m = method(:method_two_default_args)
+    assert_equal('def method_two_default_args(a=1, b=2); 42; end', m.as_expression)
+  end
+
+  def method_with_body(a, b)
+    a + b
+  end
+
+  def test_method_with_body_as_expression
+    m = method(:method_with_body)
+    assert_equal 'def method_with_body(a, b); a + b; end', m.as_expression
+  end
+
+  def test_proc_no_args_as_expression
+    p = proc { }
+    assert_equal 'proc { }', p.as_expression
+  end
+
+  def test_proc_empty_args_as_expression
+    if not defined?(VM) then
+      # indistinguishable from proc { } on YARV
+      p = proc { || }
+      assert_equal 'proc { || }', p.as_expression
+    end
+  end
+
+  def test_proc_one_arg_as_expression
+    p = proc { |a| }
+    assert_equal 'proc { |a| }', p.as_expression
+  end
+
+  def test_proc_one_array_arg_as_expression
+    p = proc { |a,| }
+    assert_equal 'proc { |a,| }', p.as_expression
+  end
+
+  def test_proc_two_args_as_expression
+    p = proc { |a, b| }
+    assert_equal 'proc { |a, b| }', p.as_expression
+  end
+
+  def test_proc_rest_arg_as_expression
+    p = proc { |*rest| }
+    assert_equal 'proc { |*rest| }', p.as_expression
+  end
+
+  def test_proc_two_args_and_rest_arg_as_expression
+    p = proc { |a, b, *rest| }
+    assert_equal 'proc { |a, b, *rest| }', p.as_expression
+  end
+
+  def test_proc_with_body_as_expression
+    p = proc { |a, b| a + b }
+    assert_equal 'proc { |a, b| a + b }', p.as_expression
+  end
+
+  def setup
+    @foo = 42
+  end
+
+  # 1.7 and later
+  def foo(*args)
+    return args
+  end
+
+  def remove_foo
+    self.class.remove_foo
+  end
+
+  # 1.6
+  def self.foo(*args)
+    return args
+  end
+
+  def self.remove_foo
+    self.class_eval { remove_const(:FOO) if const_defined?(:FOO) }
+  end
+
+  @@foo = 10
+
+  FOO = 57
+end
+
+if __FILE__ == $0 then
+  if Test::Unit.const_defined?(:AutoRunner) then
+    exit Test::Unit::AutoRunner.run
+  else
+    if ARGV.empty? then
+      suite = TC_As_Expression.suite
+    else
+      suite = Test::Unit::TestSuite.new('TC_As_Expression')
+      TC_As_Expression.suite.tests.each do |test|
+        ARGV.each do |arg|
+          suite << test if /#{arg}/ =~ test.name
+        end
+      end
+    end
+    result = Test::Unit::UI::Console::TestRunner.run(suite)
+    exit(result.error_count + result.failure_count)
+  end
+end
+