ripper2ruby 0.0.1

data/test/nodes/nodes_test.rb

@@ -0,0 +1,23 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class NodesTest < Test::Unit::TestCase
+  include TestHelper
+
+  lines = File.read(File.dirname(__FILE__) + '/../fixtures/all.rb.src').split("\n")
+  lines.each do |line|
+    next if line =~ /^#/ || line.empty?
+    define_method :"test: to_ruby(#{line}) compiles to the original src" do
+      line.gsub!('\n', "\n")
+      assert_build(line)
+    end
+  end
+  
+  Dir["#{File.dirname(__FILE__)}/../fixtures/**/*.rb"].sort.each do |filename|
+    # puts filename
+    define_method :"test: #{filename} compiles to the original src" do
+      next if filename.index('tmp.rb')
+      src = File.read(filename)
+      assert_build(src)
+    end
+  end
+end

data/test/nodes/operator_test.rb

@@ -0,0 +1,241 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class OperatorTest < Test::Unit::TestCase
+  include TestHelper
+  
+  def assert_operator(expr, src, options)
+    row    = options[:row]    || 0
+    column = options[:column] || 0
+    length = options[:length] || src.length
+
+    assert expr.root.is_a?(Ruby::Program)
+    assert_equal src, expr.to_ruby
+    assert_equal src, expr.src
+    assert_equal row, expr.row
+    assert_equal column, expr.column
+    assert_equal length, expr.length
+  end
+  
+  def assert_unary_operator(operator, options = {})
+    src = options[:src] || "#{operator}1"
+    expr = build(src).first
+    
+    assert_equal Ruby::Unary, expr.class
+    assert_equal operator.to_s, expr.operator.token
+    # assert_equal options[:value] || 1, expr.operand.value
+    
+    assert_operator(expr, src, options)
+  end
+
+  def assert_binary_operator(operator, options = {})
+    src = options[:src] || "1 #{operator} 2"
+    expr = build(src).first
+
+    assert_equal Ruby::Binary, expr.class
+    assert_equal operator.to_s, expr.operator.token
+    assert_equal options[:left]  || 1, expr.left.value
+    assert_equal options[:right] || 2, expr.right.value
+    
+    assert_operator(expr, src, options)
+  end
+  
+  # UNARY
+  
+  define_method :'test operator: +1 (+)' do
+    assert_unary_operator(:+, :src => '+a')
+  end
+  
+  define_method :'test operator: -1 (-)' do
+    assert_unary_operator(:-, :src => '-b')
+  end
+  
+  define_method :'test operator: !1 (!)' do
+    assert_unary_operator(:!)
+  end
+  
+  define_method :'test operator: not 1 (not, without parentheses)' do
+    assert_unary_operator(:not, :src => 'not 1')
+  end
+  
+  define_method :'test operator: not(1) (not, with parentheses)' do
+    assert_unary_operator(:not, :src => 'not(1)')
+  end
+  
+  define_method :'test operator: ~1 (complement/bitwise-not)' do
+    assert_unary_operator(:~)
+  end
+  
+  define_method :'test operator: (!1) (complement/bitwise-not, enclosing parentheses)' do
+    src = '(!1)'
+    assert_build(src)
+  end
+
+  define_method :"test operator: enclosing parentheses with leading space" do
+    src = 'not (@main or @sub)'
+    assert_build(src)
+  end
+  
+  # BINARY
+  
+  # arithmetical
+  
+  define_method :'test operator: 1 + 2 (plus)' do
+    assert_binary_operator :'+'
+  end
+  
+  define_method :'test operator: 1 - 2 (minus)' do
+    assert_binary_operator :'-'
+  end
+  
+  define_method :'test operator: 1 * 2 (times)' do
+    assert_binary_operator :'*'
+  end
+  
+  define_method :'test operator: 1 / 2 (over)' do
+    assert_binary_operator :'/'
+  end
+  
+  define_method :'test operator: 1 ** 2 (exponentiation)' do
+    assert_binary_operator :'**'
+  end
+  
+  define_method :'test operator: 1 % 2 (% / modulo)' do
+    assert_binary_operator :'%'
+  end
+  
+  define_method :'test operator: (1 + 2) (plus, parentheses)' do
+    src = '(1+2)'
+    assert_build(src)
+  end
+  
+  # logical
+  
+  define_method :'test operator: 1 && 2 (&& / strong logical and)' do
+    assert_binary_operator :'&&'
+  end
+  
+  define_method :'test operator: 1 || 2 (|| / strong logical or)' do
+    assert_binary_operator :'||'
+  end
+  
+  define_method :'test binary: 1 and 2 (and / weak logical and)' do
+    assert_binary_operator :'and'
+  end
+  
+  define_method :'test binary: 1 or 2 (or / weak logical or)' do
+    assert_binary_operator :'or'
+  end
+  
+  define_method :'test operator: (1 and 2) (and, parentheses)' do
+    src = '(1 and 2)'
+    assert_build(src)
+  end
+  
+  # bitwise
+  
+  define_method :'test operator: 1 << 2 (<< / left-shift)' do
+    assert_binary_operator :'<<'
+  end
+  
+  define_method :'test operator: 1 >> 2 (>> / right-shift)' do
+    assert_binary_operator :'>>'
+  end
+  
+  define_method :'test binary: 1 & 2 (& / bit-wise and)' do
+    assert_binary_operator :'&'
+  end
+  
+  define_method :'test binary: 1 | 2 (| / bit-wise or)' do
+    assert_binary_operator :'|'
+  end
+  
+  define_method :'test binary: 1 ^ 2 (^ / bit-wise xor)' do
+    assert_binary_operator :'^'
+  end
+  
+  # comparsion, equality, matching
+  
+  define_method :'test binary: 1 < 2 (comparsion, smaller)' do
+    assert_binary_operator :'<'
+  end
+  
+  define_method :'test binary: 1 <= 2 (comparsion, smaller or equal)' do
+    assert_binary_operator :'<='
+  end
+  
+  define_method :'test binary: 1 > 2 (comparsion, greater)' do
+    assert_binary_operator :'>'
+  end
+  
+  define_method :'test binary: 1 >= 2 (comparsion, greater or equal)' do
+    assert_binary_operator :'>='
+  end
+  
+  define_method :'test binary: 1 <=> 2 (spaceship)' do
+    assert_binary_operator :'<=>'
+  end
+  
+  define_method :'test binary: 1 == 2 (equals)' do
+    assert_binary_operator :'=='
+  end
+  
+  define_method :'test binary: 1 != 2 (not equals)' do
+    assert_binary_operator :'!='
+  end
+  
+  define_method :'test binary: 1 === 2 (threequals)' do
+    assert_binary_operator :'==='
+  end
+  
+  define_method :'test binary: 1 =~ 2 (matches)' do
+    assert_binary_operator :'=~'
+  end
+  
+  define_method :'test binary: 1 !~ 2 (not matches)' do
+    assert_binary_operator :'=~'
+  end
+  
+  # TERNARY
+  
+  define_method :'test ternary: 1 == 1 ? 2 : 3 (ifop)' do
+    src = '1 == 1 ? 2 : 3'
+    assert_build(src) do |node|
+      assert_equal Ruby::IfOp, node.first.class
+    end
+  end
+  
+  define_method :'test ternary: ((1) ? 2 : (3)) (ifop, parentheses)' do
+    src = '((1) ? 2 : (3))'
+    assert_build(src)
+  end
+  
+  # ======
+  
+  define_method :'test operator order in an expression with multiple identical operators' do
+    src = 'foo + bar  + baz'
+    assert_build(src)
+    # FIXME positions are messed up!
+    # assert_equal [0, 4], expr.left.operator.position.to_a
+    # assert_equal [0, 10], expr.operator.position.to_a
+  end
+  
+  define_method :'test operator order in an expression with multiple different operators' do
+    src = 'foo + bar - baz'
+    assert_build(src)
+  end
+  
+  define_method :'test operator order in an expression with multiple ternary operators (1)' do
+    src = "a ? b : c ? d : e"
+    assert_build(src)
+  end
+  
+  define_method :'test operator order in an expression with multiple ternary operators (2)' do
+    src = "a ? b ? c : d : e"
+    assert_build(src)
+  end
+
+  # define_method :'test ambiguous argument' do
+  #   src = 'a+ a +a'
+  #   assert_equal src, build(src).to_ruby(true)
+  # end
+end

data/test/nodes/separators_test.rb

@@ -0,0 +1,97 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class SeparatorsTest < Test::Unit::TestCase
+  include TestHelper
+
+  define_method :"test separators in method definition (1)" do
+    src = "def foo\n  ;bar\nend"
+    assert_build(src)
+  end
+
+  define_method :"test separators in method definition (2)" do
+    src = "def foo;\nend"
+    assert_build(src)
+  end
+end
+
+# def foo
+#   ;
+# end
+# 
+# def foo
+#   bar;
+# end
+# 
+# def foo
+#   bar
+#   ;
+# end
+# 
+# def foo
+#   ;bar
+# end
+# 
+# def foo
+#   ;
+#   bar
+# end
+# 
+# def foo
+#   ;bar;
+# end
+# 
+# def foo
+#   ;
+#   bar
+#   ;
+# end
+# 
+# def foo(a, b)
+# end
+# 
+# foo { |a, b| }
+# foo { |a, b| ; }
+# foo { |a, b| bar; }
+# foo { |a, b| ;bar }
+# 
+# foo do |a, b| 
+#   ;
+# end
+# 
+# foo do
+#   bar;
+# end
+# 
+# foo do
+#   bar
+#   ;
+# end
+# 
+# foo do
+#   ;bar
+# end
+# 
+# foo do
+#   ;
+#   bar
+# end
+# 
+# foo do
+#   ;bar;
+# end
+# 
+# foo do
+#   ;
+#   bar
+#   ;
+# end
+# 
+# begin
+#   ;
+# rescue
+#   ;
+# else
+#   ;
+# ensure
+#   ;
+# end

data/test/nodes/statements_test.rb

@@ -0,0 +1,70 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class StatementsTest < Test::Unit::TestCase
+  include TestHelper
+
+  define_method :"test parse error raises a ParseError" do
+    src = '[idx [rows, cols]]'
+    assert_raises(Ripper::RubyBuilder::ParseError) { build(src) }
+  end
+  
+  define_method :"test a body with a single call, no semicolon" do
+    src = 'foo'
+    assert_build(src)
+  end
+  
+  define_method :"test a body with a single call, lefthand semicolon" do
+    src = ';foo'
+    assert_build(src)
+  end
+  
+  define_method :"test a body with a single call, righthand semicolon" do
+    src = 'foo;'
+    assert_build(src)
+  end
+  
+  define_method :"test a body with a single call, two semicolons" do
+    src = ';foo;'
+    assert_build(src)
+  end
+  
+  define_method :"test a body with a few calls and a few semicolons (1)" do
+    src = ';foo;;bar;baz;'
+    assert_build(src)
+  end
+  
+  define_method :"test a body with a few calls and a few semicolons (2)" do
+    src = ';foo;;bar;;;;baz;'
+    assert_build(src)
+  end
+  
+  define_method :"test a body with a few calls and a few semicolons (3)" do
+    src = ';;;foo;;bar;baz;;;;'
+    assert_build(src)
+  end
+  
+  define_method :"test a nested body with a single call, no semicolon (1)" do
+    src = '(foo)'
+    assert_build(src)
+  end
+  
+  define_method :"test a nested body with a single call, no semicolon (2)" do
+    src = '(((foo)); (bar))'
+    assert_build(src)
+  end
+  
+  define_method :"test a nested body with a single call, no semicolon (2)" do
+    src = '(((foo)); ((bar); (baz)));'
+    assert_build(src)
+  end
+  
+  define_method :"test a statement with preceding and succeding whitespace" do
+    src = "\n foo \n  \n"
+    assert_build(src)
+  end
+  
+  define_method :"test ruby code using the __END__ keyword" do
+    src = "foo\n__END__\nbar"
+    assert_build(src)
+  end
+end

data/test/nodes/string_test.rb

@@ -0,0 +1,92 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class StringTest < Test::Unit::TestCase
+  include TestHelper
+  
+  def assert_string(src, value = nil, klass = Ruby::String)
+    assert_build(src) do |node|
+      assert_equal klass, node.first.class
+      assert_equal value, node.first.value if value
+    end
+  end
+
+  define_method :"test an empty string" do
+    src = '""'
+    assert_string(src, '')
+  end
+  
+  define_method :"test a double quoted string" do
+    src = '"foo"'
+    assert_string(src, 'foo')
+  end
+  
+  define_method :"test a single quoted string" do
+    src = "'foo'"
+    assert_string(src, 'foo')
+  end
+  
+  define_method :"test a percent-parens delimited string" do
+    src = "%(foo)"
+    assert_string(src, 'foo')
+  end
+  
+  define_method :"test a percent-dot delimited string" do
+    src = "%.foo."
+    assert_string(src, 'foo')
+  end
+  
+  define_method :"test a percent-pipe delimited string" do
+    src = "%|foo|"
+    assert_string(src, 'foo')
+  end
+  
+  define_method :"test a double-quoted string with an embedded expression" do
+    src = '"foo#{bar}"'
+    assert_string(src)
+  end
+  
+  define_method :"test a percent-parentheses delimited string with an embedded expression" do
+    src = '%(foo #{bar})'
+    assert_string(src)
+  end
+  
+  define_method :"test a percent-parentheses delimited string after a word-list" do
+    src = "%w(a)\n%(b)"
+    assert_build(src)
+  end
+  
+  define_method :"test a backtick delimited string" do
+    src = "`foo`"
+    assert_build(src)
+  end
+  
+  define_method :"test a percent-x delimited string" do
+    src = "%x(foo)"
+    assert_build(src)
+  end
+  
+  define_method :"test a slash delimited regexp" do
+    src = "/foo/"
+    assert_build(src)
+  end
+  
+  define_method :"test a percent-r delimited regexp" do
+    src = "%r(foo)"
+    assert_build(src)
+  end
+  
+  define_method :"test a string with a backreference" do
+    src = '"#{$1}"'
+    assert_build(src)
+  end
+  
+  define_method :"test a string with a dvar" do
+    src = '"#$0"'
+    assert_build(src)
+  end
+  
+  define_method :'test string concat' do
+    src = "'a' 'b'"
+    assert_build(src)
+  end
+end