ripper2ruby 0.0.1

data/test/nodes/args_test.rb

@@ -0,0 +1,100 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class ArgsTest < Test::Unit::TestCase
+  include TestHelper
+  
+  define_method :"test call arguments positions" do
+    src = "t('a' , 'b', 'c' => 'd', &e) { |f| g }"
+    assert_build(src) do |node|
+      assert_equal Ruby::ArgsList, node.first.arguments.class
+      assert_position [0, 0],  node.select(:token => 't')
+      assert_position [0, 1],  node.select(:token => '(')
+      assert_position [0, 2],  node.select(:value => 'a')
+      assert_position [0, 6],  node.select(:token => ',')
+      assert_position [0, 8],  node.select(:value => 'b')
+      assert_position [0, 13], node.select(:value => 'c')
+      assert_position [0, 17], node.select(:token => '=>')
+      assert_position [0, 20], node.select(:value => 'd')
+      assert_position [0, 25], node.select(Ruby::Arg).last
+      assert_position [0, 27], node.select(:token => ')')
+      assert_position [0, 29], node.select(:token => '{')
+      assert_position [0, 31], node.select(:token => '|')[0]
+      assert_position [0, 32], node.select(:token => 'f')
+      assert_position [0, 33], node.select(:token => '|')[1]
+      assert_position [0, 35], node.select(:token => 'g')
+      assert_position [0, 37], node.select(:token => '}')
+    end
+  end
+
+  define_method :'test call arguments: t("foo") (string)' do
+    src = 't("foo")'
+    assert_build(src)
+  end
+  
+  define_method :'test call arguments: t(:a => a, :b => b, &block)' do
+    src = 't(:a => a, :b => b, &c)'
+    assert_build(src) do |node|
+    end
+  end
+  
+  define_method :'test call arguments: t("foo") (string, no parentheses)' do
+    src = 't foo'
+    assert_build(src)
+  end
+  
+  define_method :"test call arguments: t :foo, :bar, :baz (3 symbols, no parentheses)" do
+    src = "t :foo, :bar, :baz"
+    assert_build(src)
+  end
+  
+  define_method :"test method call: t(:foo => :bar, :baz => :buz) (bare hash)" do
+    src = "t(:foo => :bar, :baz => :buz)"
+    assert_build(src)
+  end
+  
+  define_method :"test method call: t :a => :a do end (bare hash, no parentheses, do block)" do
+    src = "t :a => :a do end"
+    assert_build(src)
+  end
+  
+  define_method :"test method call: t({ :foo => :bar, :baz => :buz }) (hash)" do
+    src = "t({ :foo => :bar, :baz => :buz })"
+    assert_build(src)
+  end
+  
+  define_method :"test method call: t({ :foo => :bar }) (hash, leading whitespace)" do
+    src = 't ({ :foo => :bar })'
+    assert_build(src)
+  end
+  
+  define_method :"test method call: t([:foo, :bar]) (array)" do
+    src = "(t[:foo, :bar, :baz])"
+    assert_build(src)
+  end
+  
+  define_method :"test method call: t(nil) (keyword)" do
+    src = "t(nil)"
+    assert_build(src)
+  end
+  
+  define_method :"test: args with a splat call" do
+    src = "t(*a.b)"
+    assert_build(src)
+  end
+  
+  define_method :"test: args with a splat and block" do
+    src = "t(*a.b { |c| c.d })"
+    assert_build(src)
+  end
+  
+  
+  define_method :"test: replace argument" do
+    src = "(:foo, :bar)"
+    args = build('t' + src).first.arguments
+    foo, bar = args
+  
+    args[0] = baz = Ruby.from_native(:baz)
+    assert_equal args, baz.parent.parent # baz is wrapped into an Arg
+    assert_equal [0, 2], baz.position.to_a
+  end
+end

data/test/nodes/array_test.rb

@@ -0,0 +1,141 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class ArrayTest < Test::Unit::TestCase
+  include TestHelper
+
+  define_method :'test an array: [:foo, :bar]' do
+    src = '[:foo, :bar]'
+    assert_build(src) do |node|
+      assert_node node.first, :class => Ruby::Array, :value => [:foo, :bar]
+      assert_position [0, 1], node.select(:value => :foo)
+      assert_position [0, 7], node.select(:value => :bar)
+    end
+  end
+  
+  define_method :'test a wordlist array %w(foo bar) (parentheses)' do
+    src = '%w(foo bar)'
+    assert_build(src) do |node|
+      assert_node node.first, :class => Ruby::Array, :value => %w(foo bar)
+      assert_position [0, 3], node.first.select(:value => 'foo')
+      assert_position [0, 7], node.select(:value => 'bar')
+    end
+  end
+  
+  define_method :"test a percent-parens delimited string" do
+    src = "%(foo)"
+    assert_build(src)
+  end
+  
+  define_method :'test a multiline wordlist array %w(\nfoo bar\n)' do
+    src = "%w(\nfoo bar\n).foo"
+    assert_build(src)
+  end
+  
+  define_method :'test a multiline wordlist array w/ extra whitespace %w( \nfoo bar\n )' do
+    src = "%w( \nfoo bar\n ).foo"
+    assert_build(src)
+  end
+  
+  define_method :'test a wordlist array %W[foo bar] (brackets)' do
+    src = '%W[foo bar]'
+    assert_build(src)
+  end
+  
+  define_method :'test an empty wordlist (using parentheses)' do
+    src = "%w()"
+    assert_build(src)
+  end
+  
+  define_method :'test an empty wordlist (interpolating, using parentheses)' do
+    src = "%W()"
+    assert_build(src)
+  end
+  
+  define_method :'test an empty wordlist (using brackets)' do
+    src = "%w[]"
+    assert_build(src)
+  end
+  
+  define_method :'test an empty wordlist (interpolating, using brackets)' do
+    src = "%W[]"
+    assert_build(src)
+  end
+  
+  define_method :'test a wordlist with an embedded expression (using brackets)' do
+    src = "%W[\#{foo}]"
+    assert_build(src) do |node|
+      assert_position [0, 3], node.select(:class => Ruby::Statements)
+      assert_position [0, 5], node.select(:token => 'foo').first
+    end
+  end
+  
+  define_method :"test array access" do
+    src = "foo[1]"
+    assert_build(src) do |node|
+      assert_position [0, 4], node.select(:value => 1).first
+    end
+  end
+  
+  define_method :"test array access with no argument" do
+    src = "foo[]"
+    assert_build(src)
+  end
+  
+  define_method :"test array access on a call with no argument" do
+    src = "foo.bar[]"
+    assert_build(src)
+  end
+  
+  define_method :"test array w/ nested array access" do
+    src = '[ foo[bar] ]'
+    assert_build(src)
+  end
+   
+  define_method :"test array assignment" do
+    src = "result[0] = :value"
+    assert_build(src)
+  end
+  
+  define_method :'test nested array with whitespace' do
+    src = "\n  [type, [row]]\n" 
+    assert_build(src)
+  end
+  
+  define_method :'test array length: with and without whitespace' do
+    src = <<-eoc
+      [:foo]
+      [:foo  ]
+      [  :foo]
+      [  :foo  ]
+  
+      [:foo]
+      [:foo  ]
+      [  :foo]
+      [  :foo  ]
+  
+      [:foo,  :bar,  :baz]
+      [:foo , :bar , :baz]
+      [:foo  ,:bar  ,:baz]
+  
+      %w(foo)
+      %w(foo bar)
+      %w(foo  bar)
+  
+      %w( foo)
+      %w( foo bar)
+      %w( foo  bar)
+  
+      %w(foo )
+      %w(foo bar )
+      %w(foo  bar )
+  
+      %w( foo )
+      %w( foo bar )
+      %w( foo  bar )
+    eoc
+    
+    src.split("\n").map { |l| l.strip }.select { |l| !l.empty? }.each do |line|
+      assert_build(line)
+    end
+  end
+end

data/test/nodes/assignment_test.rb

@@ -0,0 +1,49 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class AssignmentTest < Test::Unit::TestCase
+  include TestHelper
+
+  define_method :'test assignment: a = b' do
+    src = 'a = b'
+    assert_build(src) do |node|
+      assert_equal Ruby::Assignment, node.first.class
+    end
+  end
+  
+  define_method :'test assignment: a ||= b' do
+    src = 'a ||= b'
+    assert_build(src)
+  end
+  
+  define_method :'test assignment: a, b = c' do
+    src = 'a, b = c'
+    assert_build(src) do |node|
+      assert_equal Ruby::Assignment, node.first.class
+      assert_equal Ruby::MultiAssignment, node.first.left.class
+    end
+  end
+  
+  define_method :'test assignment: a, b = c, d' do
+    src = 'a, b = c, d'
+    assert_build(src) do |node|
+      assert_equal Ruby::Assignment, node.first.class
+      assert_equal Ruby::MultiAssignment, node.first.left.class
+      assert_equal Ruby::MultiAssignment, node.first.right.class
+    end
+  end
+  
+  define_method :'test assignment: a, *b = c' do
+    src = 'a, *b = c'
+    assert_build(src)
+  end
+  
+  define_method :'test assignment: a, b = *c' do
+    src = 'a, b = *c'
+    assert_build(src)
+  end
+  
+  define_method :'test assignment to namespaced const: A::B = 1' do
+    src = 'A::B = 1'
+    assert_build(src)
+  end
+end

data/test/nodes/block_test.rb

@@ -0,0 +1,125 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class BlockTest < Test::Unit::TestCase
+  include TestHelper
+  
+  define_method :"test a block with an invalid param" do
+    src = 'foo { |@a| }'
+    assert_raises(Ripper::RubyBuilder::ParseError) { build(src) }
+  end
+  
+  define_method :"test method call block with 2 statements (newline delimited)" do
+    src = "t do\nfoo\nbar\nend"
+    assert_build(src)
+  end
+  
+  define_method :"test method call block with no statements, single semicolon" do
+    src = "t do ; end"
+    assert_build(src)
+  end
+  
+  define_method :"test method call block with empty params" do
+    src = "t do ||\nfoo\n end"
+    assert_build(src)
+  end
+  
+  define_method :"test method call block with semicolon delimited statements" do
+    src = "t do ;; ;foo ; ;;bar; ; end"
+    assert_build(src)
+  end
+  
+  define_method :"test: a method call block with arguments" do
+    src = "t do |(a, b), *c|\n        foo\n        bar\n      end"
+    assert_build(src)
+  end
+  
+  define_method :"test: an empty method call brace_block" do
+    src = "t { |(a, b), *c| }"
+    assert_build(src)
+  end
+  
+  define_method :"test: method call w/ do_block" do
+    src = "t do |(a, b), *c| end"
+    assert_build(src)
+  end
+  
+  define_method :"test: method call do_block with a block_param" do
+    src = "t do |*a, &c| end"
+    assert_build(src)
+  end
+  
+  define_method :"test: an empty method call brace_block w/ arg and parenthesed param" do
+    src = 't {|a, (b)| }'
+    assert_build(src)
+  end
+  
+  define_method :"test: an empty begin end block" do
+    src = "begin\nend"
+    assert_build(src)
+  end
+  
+  define_method :"test: a begin ; end block" do
+    src = "begin ; end"
+    assert_build(src)
+  end
+  
+  define_method :"test: a begin foo; end block" do
+    src = "begin foo; end"
+    assert_build(src)
+  end
+  
+  define_method :"test: a begin block with an else block" do
+    src = "begin\nfoo\nelse\nbar\nend"
+    assert_build(src)
+  end
+  
+  define_method :"test: a begin block with rescue without error_type" do
+    src = "begin\nfoo\nrescue\nbar\nend"
+    assert_build(src)
+  end
+  
+  define_method :"test: a begin block with rescue without an error_type" do
+    src = "begin \n rescue A \n end"
+    assert_build(src)
+  end
+  
+  define_method :"test: a begin block with rescue with a error_types and error_var" do
+    src = "begin foo\n rescue A => e\n bar\n end"
+    assert_build(src)
+  end
+  
+  define_method :"test: a begin block with rescue with a multiple error_types and error_var" do
+    src = "begin foo\n rescue A, B => e\n bar\n end"
+    assert_build(src)
+  end
+  
+  define_method :"test: a begin block with multiple rescues and ensure" do
+    src = "begin foo\n rescue A, B => e\n bar\nrescue C => e\n bam\nensure\nbaz\n end"
+    assert_build(src)
+  end
+  
+  define_method :"test: a begin block using rescue, then and else (from rubylexer tests)" do
+    src = "begin a; rescue NameError => e then e else :foo end"
+    assert_build(src)
+  end
+  
+  define_method :"test: multiple rescue blocks" do
+    src = "begin\nrescue A => e\nrescue B\nend"
+    assert_build(src)
+  end
+  
+  define_method :"test: rescue and else block" do
+    src = "begin\nrescue A\nelse\nend\n"
+    assert_build(src)
+  end
+  
+  define_method :"test: line with a rescue modifier yielding a method call" do
+    src = "foo rescue bar"
+    assert_build(src)
+  end
+  
+  define_method :"test: line with a rescue modifier yielding an integer" do
+    src = "foo rescue 0"
+    assert_build(src)
+  end
+end

data/test/nodes/call_test.rb

@@ -0,0 +1,229 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class CallTest < Test::Unit::TestCase
+  include TestHelper
+
+  define_method :"test a variable" do
+    src = "t"
+    assert_build(src) do |node|
+      assert_equal Ruby::Variable, node.first.class
+    end
+  end
+  
+  define_method :"test call on const target without arguments and without parantheses" do
+    src = "I18n.t"
+    assert_build(src) do |node|
+      assert_equal Ruby::Call, node.first.class
+    end
+  end
+  
+  define_method :'test method call: a.b(:foo) (var ref target, parantheses)' do
+    src = "a.b(:foo)"
+    assert_build(src)
+  end
+  
+  define_method :"test call on const target without arguments and with parantheses" do
+    src = "I18n.t()"
+    assert_build(src)
+  end
+  
+  define_method :'test method call: I18n.t("foo") (const target, double-quoted string, parantheses)' do
+    src = "I18n.t('foo')"
+    assert_build(src)
+  end
+  
+  define_method :'test method call: I18n.t "foo" (const target, double-quoted string, no parantheses)' do
+    src = "I18n.t 'foo'"
+    assert_build(src)
+  end
+  
+  define_method :"test call on const target without arguments and without parantheses (:: separator)" do
+    src = "I18n::t"
+    assert_build(src)
+  end
+  
+  define_method :"test call on const target without arguments and with parantheses (:: separator)" do
+    src = "I18n::t()"
+    assert_build(src)
+  end
+  
+  define_method :'test method call: I18n::t("foo") (const target, double-quoted string, parantheses, :: separator)' do
+    src = "I18n::t('foo')"
+    assert_build(src)
+  end
+    
+  define_method :'test method call: foo.<=>(bar) (sending an operator, srsly ... used in Rake 0.8.3)' do
+    src = "foo.<=>(bar)"
+    assert_build(src)
+  end
+    
+  define_method :'test method call: foo.<< bar (sending an operator, srsly ... used in Redmine)' do
+    src = "foo.<< bar"
+    assert_build(src)
+  end
+  
+  define_method :"test call with a string with an embedded expression" do
+    src = 'foo("#{bar}")'
+    assert_build(src)
+  end
+  
+  define_method :"test call on no target without arguments but parantheses" do
+    src = "t('foo', 'bar')"
+    assert_build(src)
+  end
+  
+  define_method :"test two method calls: t('foo'); t 'bar' (no target)" do
+    src = "t('foo', 'bar'); t 'baz'"
+    assert_build(src)
+  end
+  
+  define_method :'test method call: t "foo" (no target, double-quoted string, no parantheses)' do
+    src = "t 'foo'"
+    assert_build(src)
+  end
+  
+  define_method :'test method call: t %(foo) (no target, two percent-parentheses delimited strings w/ embedded expression)' do
+    src = 't %(foo #{bar}), %(baz)'
+    assert_build(src)
+  end
+  
+  define_method :"test call on no target without arguments but parantheses" do
+    src = "t()"
+    assert_build(src)
+  end
+  
+  define_method :"test call with nested call/parantheses" do
+    src = "t(:a, b(:b))"
+    assert_build(src)
+  end
+  
+  define_method :"test call with nested call/parantheses" do
+    src = "t(:a, b(:b))"
+    assert_build(src)
+  end
+  
+  define_method :"test call with a symbol that is a backtick" do
+    src = "t(:`)"
+    assert_build(src)
+  end
+  
+  define_method :"test call on no target without arguments but a block" do
+    src = "t do |a, b, *c|\nfoo\nend"
+    assert_build(src)
+  end
+  
+  define_method :"test call on no target without arguments but a block" do
+    src = "t do |(a, b), *c|\nfoo\nend"
+    assert_build(src)
+  end
+  
+  define_method :"test call on no target with a block var" do
+    src = "t(:foo, &block)"
+    assert_build(src)
+  end
+  
+  define_method :"test call with a call with a block as an arg" do
+    src = "foo(bar do |a| ; end)"
+    assert_build(src)
+  end
+  
+  define_method :"test call to self" do
+    src = "self.b"
+    assert_build(src)
+  end
+  
+  define_method :"test call super without arguments" do
+    src = "super"
+    assert_build(src)
+  end
+  
+  define_method :"test call super with arguments" do
+    src = "super(:foo)"
+    assert_build(src)
+  end
+  
+  define_method :"test call yield without arguments" do
+    src = "yield"
+    assert_build(src)
+  end
+  
+  define_method :"test call yield with arguments" do
+    src = "yield(:foo)"
+    assert_build(src)
+  end
+  
+  define_method :"test call alias with identifiers" do
+    src = "alias eql? =="
+    assert_build(src)
+  end
+  
+  define_method :"test call alias with symbols" do
+    src = "alias :foo :bar"
+    assert_build(src)
+  end
+  
+  define_method :"test call alias with global vars" do
+    src = "alias $ERROR_INFO $!"
+    assert_build(src)
+  end
+  
+  define_method :"test call undef with a symbol" do
+    src = "undef :foo"
+    assert_build(src)
+  end
+  
+  define_method :"test call undef with method names" do
+    src = "undef foo, bar, baz"
+    assert_build(src)
+  end
+  
+  define_method :"test call undef with an operator" do
+    src = "undef =~"
+    assert_build(src)
+  end
+  
+  define_method :"test call return" do
+    src = "return :foo"
+    assert_build(src)
+  end
+  
+  define_method :"test call next" do
+    src = "next"
+    assert_build(src)
+  end
+  
+  define_method :"test call redo" do
+    src = "redo"
+    assert_build(src)
+  end
+  
+  define_method :"test call break" do
+    src = "break"
+    assert_build(src)
+  end
+  
+  define_method :"test call retry" do
+    src = "retry"
+    assert_build(src)
+  end
+  
+  define_method :"test call to an assignment method: a.b = :c" do
+    src = "a.b = :c"
+    assert_build(src)
+  end
+  
+  define_method :"test call to defined?" do
+    src = "defined?(A)"
+    assert_build(src)
+  end
+  
+  define_method :'test BEGIN routine' do
+    src = "BEGIN { foo }"
+    assert_build(src)
+  end
+  
+  define_method :'test END routine' do
+    src = "END { foo }"
+    assert_build(src)
+  end
+end