ripper2ruby 0.0.1

data/test/nodes/case_test.rb

@@ -0,0 +1,68 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class CaseTest < Test::Unit::TestCase
+  include TestHelper
+
+  define_method :'test case expression (1)' do
+    src = "case a; when 1; 2 end"
+    assert_build(src) do |node|
+      assert_equal Ruby::Case, node.first.class
+    end
+
+  end
+  
+  define_method :'test case expression (2)' do
+    src = "case (a) when 1; 2 end"
+    assert_build(src)
+  end
+  
+  define_method :'test case expression (3)' do
+    src = "case (a;) when 1; 2 end"
+    assert_build(src)
+  end
+  
+  define_method :'test case expression (4)' do
+    src = "case (a); when 1; 2 end"
+    assert_build(src)
+  end
+  
+  define_method :'test case expression (5)' do
+    src = "case (a;); when 1; 2 end"
+    assert_build(src)
+  end
+  
+  define_method :'test case expression (6)' do
+    src = "case (a;b); when 1; 2 end"
+    assert_build(src)
+  end
+  
+  define_method :'test when expression (1)' do
+    src = "case a; when 1; 2 end"
+    assert_build(src)
+  end
+  
+  define_method :'test when expression (2)' do
+    src = "case a; when 1, 2; 2 end"
+    assert_build(src)
+  end
+  
+  define_method :'test when expression (3)' do
+    src = "case a; when (1; 2), (3; 4;); 2 end"
+    assert_build(src)
+  end
+  
+  define_method :'test case block, semicolon separated (4)' do
+    src = "case (true); when 1; false; when 2, 3, 4; nil; else; nil; end"
+    assert_build(src)
+  end
+  
+  define_method :'test case block, newline separated' do
+    src = "case true\n when 1\n false\n when 2\n nil\n else\n nil\n end"
+    assert_build(src)
+  end
+  
+  define_method :'test case block, newline separated, using then' do
+    src = "case true\n when 1 then false\n when 2 then nil\n else\n nil\n end"
+    assert_build(src)
+  end
+end

data/test/nodes/comments_test.rb

@@ -0,0 +1,25 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class CommentsTest < Test::Unit::TestCase
+  include TestHelper
+
+  define_method :"test a variable with a preceeding 3-line comment" do
+    src = "# 1\n# 2\n# 3\na"
+    assert_build(src)
+  end
+
+  define_method :"test a variable with a succeeding comment" do
+    src = "a # 1"
+    assert_build(src)
+  end
+
+  define_method :"test a block with a variable with a succeeding comment" do
+    src = "begin\n  a # 1 \nend"
+    assert_build(src)
+  end
+
+  define_method :"test a method definition with a variable with a succeeding comment" do
+    src = "def foo(a = 1)\n  a # 1 \nend"
+    assert_build(src)
+  end
+end

data/test/nodes/const_test.rb

@@ -0,0 +1,46 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class ConstTest < Test::Unit::TestCase
+  include TestHelper
+  
+  define_method :"test a const" do
+    src = 'A'
+    assert_build(src) do |node|
+      assert_equal Ruby::Const, node.first.class
+    end
+  end
+  
+  define_method :"test a module" do
+    src = "module A::B ; end"
+    assert_build(src) do |node|
+      assert_equal Ruby::Module, node.first.class
+    end
+  end
+  
+  define_method :"test a class" do
+    src = "class A::B < C ; end"
+    assert_build(src) do |node|
+      assert_equal Ruby::Class, node.first.class
+    end
+  end
+  
+  define_method :"test const on self.class" do
+    src = 'self.class::A'
+    assert_build(src)
+  end
+  
+  define_method :"test a metaclass" do
+    src = "class << self; self; end"
+    assert_build(src)
+  end
+  
+  define_method :"test a metaclass inside of a call" do
+    src = "foo (class << @bar; self; end)"
+    assert_build(src)
+  end
+  
+  define_method :"test a top-level const ref after a class def" do
+    src = "class A ; end\n::B = 3"
+    assert_build(src)
+  end
+end

data/test/nodes/conversions_test.rb

@@ -0,0 +1,9 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class ConversionsTest < Test::Unit::TestCase
+  include TestHelper
+
+  define_method :"test from_ruby" do
+    Ruby::Node.from_ruby('1')
+  end
+end

data/test/nodes/for_test.rb

@@ -0,0 +1,34 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+# for i in 1..5; ...; end
+
+class ForTest < Test::Unit::TestCase
+  include TestHelper
+
+  define_method :'test for loop, semicolon separated' do
+    src = "for i in [1]; a; end"
+    assert_build(src) do |node|
+      assert_equal Ruby::For, node.first.class
+    end
+  end
+  
+  define_method :'test for loop, newline separated' do
+    src = "for i in [1]\n a\n end"
+    assert_build(src)
+  end
+  
+  define_method :'test for loop, do block' do
+    src = "for i in [1] do a\n end"
+    assert_build(src)
+  end
+  
+  define_method :'test for loop contained in a do block' do
+    src = "lambda do\n  for a in b\n  end\nend"
+    assert_build(src)
+  end
+  
+  define_method :'test nested for loop, newline separated' do
+    src = "\nfor i in 0...1 do\n  for j in 0...2 do\n  end\nend\n"
+    assert_build(src)
+  end
+end

data/test/nodes/hash_test.rb

@@ -0,0 +1,71 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class HashTest < Test::Unit::TestCase
+  include TestHelper
+  
+  def hash(src)
+    build(src).first
+  end
+
+  define_method :'test a hash: { :foo => :bar }' do
+    src = '{ :foo => :bar }'
+    assert_build(src) do |node|
+      assert_equal Ruby::Hash, node.first.class
+      assert_equal({ :foo => :bar }, node.first.value)
+    end
+  end
+
+  define_method :'test a nested hash: { :a => { :b => { :b => :c, }, }, } (w/ dangling commas)' do
+    src = '{ :a => { :b => { :b => :c, }, }, }'
+    assert_build(src) do |node|
+      assert_equal Ruby::Hash, node.first.class
+      assert_equal({ :a => { :b => { :b => :c } } }, node.first.value)
+    end
+  end
+  
+  define_method :'test a bare nested hash: t(:a => { :b => :b, :c => { :d => :d } })' do
+    src = 't(:a => { :b => :b, :c => { :d => :d } })'
+    assert_build(src)
+  end
+  
+  define_method :'test a hash: { :if => :delete } (symbol that is a keyword)' do
+    src = "{ :if => :foo }"
+    assert_build(src)
+  end
+  
+  define_method :'test a hash: { :if => :delete } (symbol that is a keyword)' do
+    src = '{ :a => :a, :b => "#{b 1}" }'
+    assert_build(src)
+  end
+  
+  define_method :'test a hash: { foo: bar } (Ruby 1.9 labels)' do
+    src = "{ foo: bar }"
+    assert_build(src)
+  end
+  
+  define_method :'test a bare hash: t(:foo => :bar)' do
+    src = 't(:a => :a, :b => :b)'
+    assert_build(src)
+  end
+  
+  define_method :'test hash assignment' do
+    src = "foo[:bar] = :baz"
+    assert_build(src)
+  end
+  
+  define_method :'test hash length: with and without whitespace' do
+    assert_equal 22, build("  {:a=>:a,:b=>:b,:c=>:c}").first.length
+    assert_equal 30, build("  {:a => :a, :b => :b, :c => :c}").first.length
+    assert_equal 30, build("  { :a=>:a ,  :b=>:b  , :c=>:c }").first.length
+    assert_equal 32, build("  { :a => :a, :b => :b, :c => :c }").first.length
+    assert_equal 34, build("  { :a => :a, :b => :b, :c => :c }").first.length(true)
+  end
+  
+  define_method :'test bare hash length: with and without whitespace' do
+    assert_equal 20, build("  t(:a=>:a,:b=>:b,:c=>:c)").first.arguments.first.length
+    assert_equal 28, build("  t(:a => :a, :b => :b, :c => :c)").first.arguments.first.length
+    assert_equal 26, build("  t( :a=>:a ,  :b=>:b  , :c=>:c )").first.arguments.first.length
+    assert_equal 28, build("  t( :a => :a, :b => :b, :c => :c )").first.arguments.first.length
+    assert_equal 29, build("  t( :a => :a, :b => :b, :c => :c )").first.arguments.first.length(true)
+  end
+end

data/test/nodes/heredoc_test.rb

@@ -0,0 +1,202 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class HeredocTest < Test::Unit::TestCase
+  include TestHelper
+
+  define_method :"test an empty heredoc" do
+    src = "\n<<-eos\neos\n"
+    assert_build(src)
+  end
+
+  define_method :"test a heredoc" do
+    src = "<<-eos\nfoo\neos"
+    assert_build(src)
+  end
+
+  define_method :"test a heredoc and strings" do
+    src = "'string'\n<<-eos\nheredoc\neos\n'string'"
+    assert_build(src)
+  end
+
+  define_method :"test a heredoc and dyna symbols" do
+    src = ":'symbol'\n<<-eos\nheredoc\neos\n:'symbol'"
+    assert_build(src)
+  end
+
+  define_method :"test a heredoc and words" do
+    src = "%w(words)\n<<-eoc\n  heredoc\neoc\n%w(words)"
+    assert_build(src)
+  end
+
+  define_method :"test a heredoc and a call with words" do
+    src = "foo(%w(words))\n<<-eoc\n\neoc"
+    assert_build(src)
+  end
+
+  define_method :"test a heredoc with a semicolon" do
+    src = "\n<<-end;\nfoo\nend\n"
+    assert_build(src)
+  end
+
+  define_method :"test a quoted heredoc with extra whitespace and a semicolon" do
+    src = "\n<<-'end'   ;\n  foo\nend\nfoo;"
+    assert_build(src)
+  end
+
+  define_method :"test a heredoc with an embedded expression" do
+    src = "<<-eos\n  foo \#{bar} baz\neos"
+    assert_build(src)
+  end
+
+  define_method :"test a heredoc with an embedded array access" do
+    src = "<<-end\n\#{a['b']}\nend"
+    src = "<<-end\n\#{'a'}\nend"
+    assert_build(src)
+  end
+
+  define_method :"test method call with heredoc" do
+    src = "foo(<<-eos)\n  foo\neos"
+    assert_build(src)
+  end
+
+  define_method :"test method call with heredoc (2)" do
+    src = "foo(<<-eos\n  foo\neos\n)"
+    assert_build(src)
+  end
+
+  define_method :"test method call with heredoc with arguments" do
+    src = "foo(<<-eos, __FILE__, __LINE__)\n  foo\neos"
+    assert_build(src)
+  end
+
+  define_method :"test method call with heredoc with arguments / operator" do
+    src = "foo(<<-eos, __FILE__, __LINE__ + 1)\n  foo\neos"
+    assert_build(src)
+  end
+
+  define_method :"test method call with heredoc with arguments / call" do
+    src = "foo(<<-eos, __FILE__, line)\n  foo\neos"
+    assert_build(src)
+  end
+
+  define_method :"test method call with heredoc with a string arg with an embedded expression" do
+    src = "foo(<<-eos, \"\#{bar}\")\n  foo\neos"
+    assert_build(src)
+  end
+
+  define_method :"test a begin block with a heredoc" do
+    src = "begin <<-src \n\n\nfoo\nsrc\n end"
+    assert_build(src)
+  end
+
+  define_method :"test a do block with a heredoc and an embedded expression" do
+    src = "each do\n <<-src \n\nfoo\n\#{bar}\nsrc\n end\n"
+    assert_build(src)
+  end
+
+  define_method :"test heredoc with a nested embedded expression" do
+    src = "<<-eos\n  \#{\"\n    \#{sym}\n  \"}\neos"
+    assert_build(src)
+  end
+
+  define_method :"test heredoc with a multiline embedded expression" do
+    src = "<<-eos\n \t\#{ a\n  }\neos"
+    assert_build(src)
+  end
+
+  define_method :"test heredoc with an embedded expression containing a dyna_symbol" do
+    src = "<<-eos\n\#{:'dyna_symbol'}\neos"
+    assert_build(src)
+  end
+
+  define_method :"test a heredoc with a comment on the first line" do
+    src = "<<-eos # comment\neos\nfoo\nfoo\n"
+    assert_build(src)
+  end
+
+  define_method :"test a heredoc with a comment on the first line, followed by a single-quoted string" do
+    src = "<<-eos # comment\nstring\neos\n'index'"
+    assert_build(src)
+  end
+
+  define_method :"test command_call w/ a heredoc with an if modifier on heredoc_beg" do
+    src = "foo <<-eos if bar\na\neos\nbaz"
+    assert_build(src)
+  end
+
+  define_method :"test a heredoc with a method call on the heredoc_beg token" do
+    src = "<<-eos.foo\neos\nbar\n"
+    assert_build(src)
+  end
+
+  define_method :"test a heredoc with an xstring as a heredoc_beg token" do
+    src = "foo = <<-`foo`\nfoo"
+    assert_build(src)
+  end
+
+  define_method :"test multiple heredocs" do
+    src = "<<-end\nend\n<<-end\n\nend\n"
+    assert_build(src)
+  end
+
+  define_method :"test a stacked quoted heredoc" do
+    src = 'heredocs = <<-"foo", <<-"bar"
+        I said foo.
+      foo
+        I said bar.
+      bar
+    '
+    assert_build(src)
+  end
+
+  define_method :"test a heredoc after an empty words list" do
+    src = "a = %w[]\n<<-eos\nfoo\neos"
+    assert_build(src)
+  end
+
+  define_method :"test a heredoc containing an __END__ keyword" do
+    src = "<<-eos\nfoo\n__END__\neos"
+    assert_build(src)
+  end
+
+  define_method :"test a stuffed heredoc (from rubylexer tests)" do
+    src = <<-eos
+p <<stuff+'foobar'.tr('j-l','d-f') \\
++"more stuff"
+12345678
+the quick brown fox jumped over the lazy dog
+stuff
+eos
+    assert_build(src)
+  end
+
+  define_method :"test a stuffed heredoc (from rubylexer tests) (2)" do
+    src = <<-eos
+p(<<stuff+'foobar')\\
++"more stuff"
+some stuff
+stuff
+eos
+    assert_build(src)
+  end
+
+  define_method :"test a stuffed heredoc (from rubylexer tests) (3)" do
+    src = <<-eos
+p <<stuff+'foobar' \\
++"more stuff"
+some stuff
+stuff
+eos
+    assert_build(src)
+  end
+
+  define_method :"test a stuffed heredoc (from rubylexer tests) (4)" do
+    src = <<-eos
+p <<stuff+'foobar'+
+some stuff
+stuff
+"more stuff"
+eos
+    assert_build(src)
+  end
+end