ruby-internal 0.6.0

data/test/expression_samples.rb

@@ -0,0 +1,160 @@
+require 'rbconfig'
+
+class TEST_CLASS
+  FOO = 10
+end
+
+EXPRESSION_SAMPLES = {
+  :lit                     => '42',
+  :vcall                   => 'foo',
+  :fcall                   => 'foo()',
+  :fcall_many              => 'foo(1, 2, 3)',
+  :fcall_many2             => 'foo 1, 2, 3',
+  :fcall_splat             => 'a = [2, 3]; foo(1, *a)',
+  :fcall_block             => 'foo() { nil }',
+  :fcall_block_with_args   => 'foo() { |x,y| [x, y] }',
+  :plus                    => '1+1',
+  :minus                   => '54-2',
+  :times                   => '12*6',
+  :div                     => '16/7',
+  :less                    => '8 < 5',
+  :less_eq                 => '8 <= 5',
+  :greater                 => '8 > 5',
+  :greater_eq              => '8 >= 5',
+  :equal                   => '8 == 5',
+  :threequal               => '8 === 5',
+  :spaceship               => "8 <=\> 5", # the \> is for Align.vim
+  :lshift                  => '8 << 5 ',
+  :rshift                  => '8 >> 5',
+  :bit_and                 => '8 & 5',
+  :bit_or                  => '8 | 5',
+  :bit_xor                 => '8 ^ 5',
+  :mod                     => '8 % 5',
+  :not_equal               => '8 != 5',
+  # TODO: :match           => ''foo' =~ /foo|bar/',
+  # TODO: :not_match       => ''foo' !~ /foo|bar/',
+  :call                    => 'self.foo',
+  # TODO: super
+  # TODO: zsuper
+  # TODO: redo
+  # TODO: retry
+  :sym_not                 => '!true',
+  :sym_and                 => 'true && false',
+  :sym_or                  => 'true || false',
+  :lit_not                 => 'not true',
+  :lit_and                 => 'true and false',
+  :lit_or                  => 'true or false',
+  :array                   => '[1, 2, 3]',
+  :zarray                  => '[]',
+  :array_splat             => '[1, 2, *[3, 4]]',
+  :array_splat_var         => 'a = [3, 4]; [1, 2, *a]',
+  # TODO: block
+  :hash                    => '{ 1 => 2, 2 => 3 }',
+  :zhash                   => '{}',
+  :ternary                 => 'true ? false : nil',
+  :if                      => 'if true then false; else nil; end',
+  :if2                     => '42 if true',
+  :true                    => 'true',
+  :false                   => 'false',
+  :nil                     => 'nil',
+  :self                    => 'self',
+  :dot2                    => '5..8',
+  :dot3                    => '5...8',
+  :gvar                    => '$stdout',
+  :ivar                    => '@foo',
+  :cvar                    => '@@foo',
+  :dvar                    => 'foo = 1; foo',
+  :nth_ref                 => '$1',
+  :back_ref                => '$`',
+  :dasgn_curr              => 'foo = 1',
+  # TODO: dasgn
+  :iasgn                   => '@foo = 6',
+  # TODO: lasgn
+  :masgn                   => 'a, b = 1, 2',
+  :masgn_with_one_value    => 'a, b = 1',
+  :cdecl                   => 'remove_foo; FOO = 1',
+  :cvdecl                  => '@@foo = 1',
+  # TODO: cvasgn
+  :attrasgn                => 'h = {}; h.default = true; h',
+  :const                   => 'FOO',
+  :colon2                  => 'self::FOO',
+  :colon3                  => '::TEST_CLASS::FOO',
+  # TODO: lvar
+  # TODO: newline
+  :str                     => '"foo"',
+  :regx                    => '/foo/',
+  # TODO: :regx_cflag      => '/foo/i',
+  :regx_once               => '/foo/o',
+  # :regx_once_cflag       => '/foo/oi',
+  # TODO: xstr
+  :dstr                    => 'a = 1; b = 2; "#{a}#{b}"',
+  :dregx                   => 'a = 1; b = 2; /#{a}#{b}/',
+  # :dregx_cflag           => 'a = 1; b = 2; /#{a}#{b}/i',
+  :dregx_once              => 'a = 1; b = 2; /#{a}#{b}/',
+  # :dregx_once_cflag      => 'a = 1; b = 2; /#{a}#{b}/oi',
+  # TODO dregx with next set
+  # TODO: dxstr
+  # TODO: evstr
+  :iter                    => 'loop { break }',
+  :iter_x                  => 'loop { break 10 }',
+  :while_1                 => 'while true; break; end',
+  :while_1_x               => 'while true; break 7; end',
+  :while_1_do              => 'while true do; break; end',
+  :while_1_do_x            => 'while true do; break 7; end',
+  :while_0                 => 'begin; break; end while true',
+  :while_0_x               => 'begin; break 7; end while true',
+  :until_1                 => 'until false; break; end',
+  :until_1_x               => 'until false; break 7; end',
+  :until_1_do              => 'until false do; break; end',
+  :until_1_do_x            => 'until false do; break 7; end',
+  :until_0                 => 'begin; break; end until false',
+  :until_0_x               => 'begin; break 7; end until false',
+  :break                   => 'break',
+  :break_x                 => 'break 49',
+  :catch                   => 'catch(:foo) { throw :foo; 42 }',
+  # TODO: yield
+  :begin                   => 'begin; 42; end',
+  :begin_empty             => 'begin; end',
+  :begin_ensure            => 'begin; 7; ensure; 42; end',
+  :begin_ensure_empty_head => 'begin; ensure; 42; end',
+  :begin_ensure_empty_body => 'begin; ensure; end',
+  :rescue                  => 'raise "foo" rescue 7',
+  :rescue2                 => 'raise "foo"; 42 rescue 7',
+  :begin_rescue            => 'begin; raise "foo"; rescue; 42; end',
+  :begin_rescue_multi      => 'begin; raise "foo"; 6; rescue; 42; end',
+  :begin_rescue_empty_head => 'begin; rescue; end',
+  :begin_rescue_empty_resq => 'begin; 42; rescue; end',
+  :resbody                 => 'begin; raise "foo"; rescue; 42; end',
+  :case_when               => 'case 42; when TrueClass then 6; when Fixnum then 42; end',
+  :case_when_multi_arg     => 'case 42; when TrueClass, Fixnum then 42; end',
+  :case_when_empty_body    => 'case 42; when TrueClass; when Fixnum then 42; end',
+  # TODO: alias
+  # TODO: valias
+  :undef                   => 'define_method(:a) { }; undef :a',
+  # TODO: class
+  # TODO: sclass
+  # TODO: scope
+  # TODO: defn
+  # TODO: defs
+  :defined                 => 'defined?(NilClass)',
+  # TODO: match3
+  :op_asgn2                => 'OWFA.foo = 0; OWFA.foo += 1',
+}
+
+
+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
+
+if ruby_version_code < 170 then
+  EXPRESSION_SAMPLES.delete(:break_x)
+  EXPRESSION_SAMPLES.delete(:iter_x)
+  EXPRESSION_SAMPLES.delete(:while_1_x)
+  EXPRESSION_SAMPLES.delete(:while_1_do_x)
+  EXPRESSION_SAMPLES.delete(:while_0_x)
+  EXPRESSION_SAMPLES.delete(:until_1_x)
+  EXPRESSION_SAMPLES.delete(:until_1_do_x)
+  EXPRESSION_SAMPLES.delete(:until_0_x)
+end
+

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_as_code.rb

@@ -0,0 +1,261 @@
+require 'test/unit'
+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 'internal/node/as_code'
+require 'internal/method/as_code'
+require 'internal/module/as_code'
+require 'internal/proc/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,
+          "Expected #{exc_orig.inspect} but got #{exc_new.inspect} " + \
+          "(code_orig=#{code}, code_new=#{code_new})")
+      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.
+    catch(:invalid_test) { super(test_method_name) }
+  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?(RubyVM) 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
+
+  class ObjectWithFooAccessor
+    attr_accessor :foo
+  end
+
+  OWFA = ObjectWithFooAccessor.new
+end
+
+if __FILE__ == $0 then
+  require 'test/unit/ui/console/testrunner'
+
+  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
+