ruby-internal 0.8.2 → 0.8.3

data/lib/internal/vm/iseq/as_code.rb

@@ -1,27 +0,0 @@
-require 'internal/vm'
-
-if defined?(RubyVM::InstructionSequence) then
-  require 'internal/vm/bytedecoder'
-
-  class RubyVM
-    class InstructionSequence
-      def as_code(indent=0)
-        env = Internal::ByteDecoder::Environment.new(local_table())
-        opt_pc = self.opt_pc
-        self.bytedecode(env, opt_pc)
-        expressions = env.expressions + env.stack
-        if expressions.length == 0 then
-          return nil
-        elsif expressions.length == 1 and
-           expressions[0].is_a?(Internal::ByteDecoder::Expression::Literal) and
-           expressions[0].value == nil then
-          return nil
-        else
-          expressions.map! { |e| "#{'  '*indent}#{e}" }
-          return expressions.join("\n")
-        end
-      end
-    end
-  end
-end
-

data/lib/internal/vm/iseq/as_expression.rb

@@ -1,26 +0,0 @@
-require 'internal/vm'
-
-if defined?(RubyVM::InstructionSequence) then
-  require 'internal/vm/bytedecoder'
-
-  class RubyVM
-    class InstructionSequence
-      def as_expression
-        env = Internal::ByteDecoder::Environment.new(local_table())
-        opt_pc = self.opt_pc
-        self.bytedecode(env, opt_pc)
-        expressions = env.expressions + env.stack
-        if expressions.length == 0 then
-          return nil
-        elsif expressions.length == 1 and
-           expressions[0].is_a?(Internal::ByteDecoder::Expression::Literal) and
-           expressions[0].value == nil then
-          return nil
-        else
-          return expressions.join('; ')
-        end
-      end
-    end
-  end
-end
-

data/test/expression_samples.rb

@@ -1,160 +0,0 @@
-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/test_as_code.rb

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