ripper2ruby 0.0.1

data/test/nodes/identifier_test.rb

@@ -0,0 +1,51 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class IdentifierTest < Test::Unit::TestCase
+  include TestHelper
+
+  define_method :"test a variable" do
+    src = 'foo'
+    identifier = build(src).first
+    assert_build(src) do |node|
+      assert_equal Ruby::Variable, node.first.class
+    end
+  end
+  
+  define_method :"test an instance variable" do
+    src = '@foo'
+    assert_build(src) do |node|
+      assert_equal Ruby::Variable, node.first.class
+    end
+  end
+  
+  define_method :"test a class variable" do
+    src = '@@foo'
+    assert_build(src) do |node|
+      assert_equal Ruby::Variable, node.first.class
+    end
+  end
+  
+  define_method :"test a global variable" do
+    src = '$foo'
+    assert_build(src) do |node|
+      assert_equal Ruby::Variable, node.first.class
+    end
+  end
+  
+  define_method :"test keyword __FILE__" do
+    src = '__FILE__'
+    assert_build(src) do |node|
+      assert_equal Ruby::Keyword, node.first.class
+    end
+  end
+  
+  define_method :"test keyword __LINE__" do
+    src = '__LINE__'
+    assert_build(src)
+  end
+  
+  define_method :"test keyword __ENCODING__" do
+    src = '__ENCODING__'
+    assert_build(src)
+  end
+end

data/test/nodes/if_test.rb

@@ -0,0 +1,100 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class IfTest < Test::Unit::TestCase
+  include TestHelper
+
+  define_method :'test if block, semicolon separated' do
+    src = "if true; false end"
+    assert_build(src)
+  end
+  
+  define_method :'test if block, newline separated' do
+    src = "if true\n false\n end"
+    assert_build(src)
+  end
+  
+  define_method :'test if block, newline separated' do
+    src = "if true\n false\n end"
+    assert_build(src)
+  end
+
+  define_method :'test if block w/ then, not separated' do
+    src = "if true then false end"
+    assert_build(src)
+  end
+  
+  define_method :'test if block w/ else block, semicolon separated' do
+    src = "if true; false; else; true end"
+    assert_build(src)
+  end
+  
+  define_method :'test if block w/ else block, newline separated' do
+    src = "if true\n false\n else\n true end"
+    assert_build(src)
+  end
+  
+  define_method :'test if block w/ elsif block, semicolon separated' do
+    src = "if true; false; elsif false; true end"
+    assert_build(src)
+  end
+  
+  define_method :'test if block w/ elsif block, newline separated' do
+    src = "if true\n false\n elsif false\n true end"
+    assert_build(src)
+  end
+  
+  define_method :'test if block w/ then, else block and elsif block, semicolon separated' do
+    src = "if true then false; elsif false then true; else nil end"
+    assert_build(src)
+  end
+  
+  define_method :'test if block w/ then, else block and elsif block, newline separated' do
+    src = "if a == 1 then b\nelsif b == c then d\ne\nf\nelse e end"
+    assert_build(src)
+  end
+  
+  define_method :'test if modifier' do
+    src = "foo if true"
+    assert_build(src)
+  end
+  
+  define_method :'test if modifier after a keyword statement' do
+    src = "return if true"
+    assert_build(src)
+  end
+  
+  define_method :'test if modifier after an assignment to call' do
+    src = 'foo.bar += bar if bar'
+    assert_build(src)
+  end
+  
+  define_method :'test if modifier after call multiassignment with a splat' do
+    src = 'foo, bar = *baz if bum'
+    assert_build(src)
+  end
+  
+  define_method :'test if modifier after call with a splat argument' do
+    src = 'foo *args if bar?'
+    assert_build(src)
+  end
+  
+  define_method :'test if modifier after array access' do
+    src = 'pos[1] if pos'
+    assert_build(src)
+  end
+  
+  define_method :'test if modifier testing defined?' do
+    src = 'a if (defined? a)'
+    assert_build(src)
+  end
+  
+  define_method :'test rescue modifier' do
+    src = 'rescued rescue rescuing'
+    assert_build(src)
+  end
+  
+  define_method :'test rescue modifier after assignment' do
+    src = 'rescued = assigned rescue rescueing'
+    assert_build(src)
+  end
+end

data/test/nodes/literals_test.rb

@@ -0,0 +1,63 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class LiteralsTest < Test::Unit::TestCase
+  include TestHelper
+
+  define_method :"test an integer" do
+    src = '1'
+    assert_build(src) do |node|
+      assert_equal Ruby::Integer, node.first.class
+    end
+  end
+
+  define_method :"test a float" do
+    src = '1.1'
+    assert_build(src) do |node|
+      assert_equal Ruby::Float, node.first.class
+    end
+  end
+
+  define_method :"test nil" do
+    src = 'nil'
+    assert_build(src) do |node|
+      assert_equal Ruby::Nil, node.first.class
+    end
+  end
+
+  define_method :"test true" do
+    src = 'true'
+    assert_build(src) do |node|
+      assert_equal Ruby::True, node.first.class
+    end
+  end
+
+  define_method :"test false" do
+    src = 'false'
+    assert_build(src) do |node|
+      assert_equal Ruby::False, node.first.class
+    end
+  end
+
+  define_method :"test range (..)" do
+    src = '1..2'
+    assert_build(src) do |node|
+      assert_equal Ruby::Range, node.first.class
+    end
+  end
+
+  define_method :"test range (..)" do
+    src = '1...2'
+    literal = build(src).first
+    assert literal.is_a?(Ruby::Range)
+    assert_equal 1...2, literal.value
+    assert_equal src, literal.to_ruby
+  end
+
+  define_method :"test character" do
+    src = '?a'
+    literal = build(src).first
+    assert literal.is_a?(Ruby::Char)
+    assert_equal 'a', literal.value
+    assert_equal src, literal.to_ruby
+  end
+end

data/test/nodes/method_test.rb

@@ -0,0 +1,92 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class MethodTest < Test::Unit::TestCase
+  include TestHelper
+
+  define_method :"test a method definition" do
+    src = "def foo(a, b = nil, c = :foo, *d, &block)\n        bar\n        baz\n      end"
+    assert_build(src)
+  end
+  
+  define_method :"test a method definition with an options hash" do
+    src = "def foo(a, b = {})\nend"
+    assert_build(src)
+  end
+  
+  define_method :"test a method definition without parentheses" do
+    src = "def foo a, b = nil, c = :foo, *d, &block\n        bar\n        baz\n      end"
+    assert_build(src)
+  end
+  
+  define_method :"test a class method definition (using self, keyword)" do
+    src = "def self.for(options)\nend"
+    assert_build(src)
+  end
+  
+  define_method :"test method definition: def foo(b = :b, c=:c); end (optional args w/ whitespace differences)" do
+    src = 'def foo(a = 1, b=2); end'
+    assert_build(src)
+  end
+  
+  define_method :"test method definition: def t(a = []); end" do
+    src = "def t(a = []) end"
+    assert_build(src)
+  end
+  
+  define_method :"test: method definition: def t(*) end (a single splat)" do
+    src = "def t(*) end"
+    assert_build(src)
+  end
+  
+  define_method :"test method definition: def <<()" do
+    src = "def <<(arg) end"
+    assert_build(src)
+  end
+  
+  define_method :"test method definition: def | " do
+    src = "def | ; end"
+    assert_build(src)
+  end
+  
+  define_method :"test method definition: def |(foo) " do
+    src = "class A < B; def |(foo); end; end"
+    assert_build(src)
+  end
+  
+  define_method :"test method body w/ statements separated by semicolon" do
+    src = "def <<(arg) foo; bar; end"
+    assert_build(src)
+  end
+  
+  define_method :"test method body rescue with error var" do
+    src = "def t\nrescue => e\nend"
+    assert_build(src)
+  end
+  
+  define_method :"test method body rescue and ensure block" do
+    src = "def a(b, c)\n  d\nrescue A\n e\nensure\nb\nend"
+    assert_build(src)
+  end
+  
+  define_method :"test a method definition with a semicolon and a block in the body" do
+    src = "def foo ; bar { |k, v| k }  end"
+    assert_build(src)
+  end
+  
+  define_method :"test a method definition with an identifier that is also a keyword (?) (class)" do
+    src = "class A\n  def class\n  end\nend"
+    assert_build(src)
+  end
+  
+  define_method :"test a method definition with an identifier that is also a keyword (?) (end)" do
+    src = "def end\nend"
+    assert_build(src)
+  end
+  
+  define_method :"test a method definition that returns a number" do
+    src = "def def; 234; end"
+    assert_build(src)
+  end
+  
+  
+end

data/test/nodes/namespaces_test.rb

@@ -0,0 +1,65 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class NamespacesTest < Test::Unit::TestCase
+  include TestHelper
+  
+  define_method :'test method definition and call: def A::foo() B::foo(); end (multiple :: separators)' do
+    src = "def A::foo() B::foo(); end"
+    assert_build(src)
+  end
+  
+  define_method :'test method call: A::B::\nfoo() (multiple :: separators)' do
+    src = "C::\nD::foo()"
+    assert_build(src)
+  end
+  
+  define_method :"test a const path" do
+    src = 'A::B::C'
+    assert_build(src)
+  end
+  
+  define_method :"test a const path" do
+    src = "A::B::C::\nD"
+    assert_build(src)
+  end
+  
+  define_method :"test a const path with toplevel const ref" do
+    src = '::A::B'
+    assert_build(src)
+  end
+  
+  define_method :"test namespace separator with method call and const argument" do
+    src = 'A::foo(B)'
+    assert_build(src)
+  end
+  
+  define_method :"test namespace separator in a method definition" do
+    src = 'def A::foo(); end'
+    assert_build(src)
+  end
+  
+  define_method :"test namespaced const after namespace separator in a method definition" do
+    src = "def A::foo(); end\n::B::C"
+    assert_build(src)
+  end
+  
+  define_method :"test use const after namespace separator in a method definition" do
+    src = "def A::foo()\n    a = B\n  end"
+    assert_build(src)
+  end
+  
+  define_method :"test a nested namespaced class" do
+    src = "class A < B::C\nclass D\nend\nend"
+    assert_build(src)
+  end
+  
+  define_method :"test a class method definition calling a class method (namespace seps)" do
+    src = "def A::foo()\nB::foo()\n end"
+    assert_build(src)
+  end
+  
+  define_method :"test a class method definition (using const) containing a class method call (using ::)" do
+    src = "def A.foo(a, b = nil, c = :foo, *d, &block)\n        A::B()\n        baz\n      end"
+    assert_build(src)
+  end
+end

data/test/nodes/node_test.rb

@@ -0,0 +1,74 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class NodeTest < Test::Unit::TestCase
+  def statements(src)
+    Ripper::RubyBuilder.build(src).statements
+  end
+  
+  # def test_src_pos
+  #   statements = statements("  aaaaaaa\nbbbbb\ncccc(:c)\nddd\nee\nf")
+  #   assert_equal 2,  statements[0].src_pos
+  #   assert_equal 10, statements[1].src_pos
+  #   assert_equal 16, statements[2].src_pos
+  #   assert_equal 21, statements[2].arguments.first.src_pos
+  #   assert_equal 25, statements[3].src_pos
+  #   assert_equal 29, statements[4].src_pos
+  #   assert_equal 32, statements[5].src_pos
+  # end
+  
+  # def test_update_position
+  #   program = Ripper::RubyBuilder.build("a\nb\nc(:c); d(:d); e(:e)\nf")
+  #   
+  #   b = program.statements[1]
+  #   c = program.statements[2]
+  #   d = program.statements[3]
+  #   e = program.statements[4]
+  #   f = program.statements[5]
+  #   
+  #   assert_equal [1, 0],  b.position
+  #   assert_equal [2, 0],  c.position
+  #   assert_equal [2, 7],  d.position
+  #   assert_equal [2, 14], e.position
+  #   assert_equal [3, 0],  f.position
+  # 
+  #   program.send(:update_positions, 2, c.length, 3)
+  #   
+  #   assert_equal [1, 0],  b.position
+  #   assert_equal [2, 0],  c.position
+  #   assert_equal [2, 10], d.position
+  #   assert_equal [2, 17], e.position
+  #   assert_equal [3, 0],  f.position
+  # end
+  # 
+  # def test_update_children_positions
+  #   program = Ripper::RubyBuilder.build("a(:a); b(:b, ['b', 1], { :b => :'b' })")
+  #   
+  #   a = program.statements.select { |s| s.identifier.token == 'a' if s }.first
+  #   b = program.statements.select { |s| s.identifier.token == 'b' if s }.first
+  #   
+  #   assert_equal [0, 0],  a.position
+  #   assert_equal [0, 7],  b.position
+  #   assert_equal [0, 9],  b.arguments[0].position
+  #   assert_equal [0, 13], b.arguments[1].position
+  #   assert_equal [0, 14], b.arguments[1][0].position
+  #   assert_equal [0, 19], b.arguments[1][1].position
+  #   assert_equal [0, 23], b.arguments[2].position
+  #   assert_equal [0, 25], b.arguments[2].assocs[0].position
+  #   assert_equal [0, 25], b.arguments[2].assocs[0].key.position
+  #   assert_equal [0, 31], b.arguments[2].assocs[0].value.position
+  #   v = b.arguments[2].assocs[0].value
+  # 
+  #   program.send(:update_positions, 0, a.length, 3)
+  # 
+  #   assert_equal [0, 0],  a.position
+  #   assert_equal [0, 10], b.position
+  #   assert_equal [0, 12], b.arguments[0].position
+  #   assert_equal [0, 16], b.arguments[1].position
+  #   assert_equal [0, 17], b.arguments[1][0].position
+  #   assert_equal [0, 22], b.arguments[1][1].position
+  #   assert_equal [0, 26], b.arguments[2].position
+  #   assert_equal [0, 28], b.arguments[2].assocs[0].position
+  #   assert_equal [0, 28], b.arguments[2].assocs[0].key.position
+  #   assert_equal [0, 34], b.arguments[2].assocs[0].value.position
+  # end
+end