ruby_parser 2.2.0 → 2.3.0

data/History.txt

@@ -1,3 +1,16 @@
+=== 2.3.0 / 2011-09-06
+
+* 2 minor enhancements:
+
+  * Add -g flag to parser compile if DEBUG
+  * Lexer now embeds line number in yacc_value for keywords, helping fix up line numbers
+
+* 3 bug fixes:
+
+  * Fix method line numbers when no args and no parens (quix)
+  * Fixed line numbers on return/break/next w/ result expr. (pjnz)
+  * Fixed some lexing state in order to parse: 'f (1), 2' as 'f(1, 2)'. (invernizzi)
+
 === 2.2.0 / 2011-08-23
 
 * 2 minor enhancements:

data/Rakefile

@@ -17,6 +17,8 @@ Hoe.spec 'ruby_parser' do
   dependency 'sexp_processor', '~> 3.0'
 
   self.perforce_ignore << "lib/ruby_parser.rb" if plugin? :perforce
+
+  self.racc_flags << " -g" if plugin?(:racc) && ENV["DEBUG"]
 end
 
 task :clean do
@@ -101,4 +103,8 @@ task :huh? do
   puts "ruby #{Hoe::RUBY_FLAGS} bin/ruby_parse -q -g ..."
 end
 
+task :irb => [:isolate] do
+  sh "GEM_HOME=#{Gem.path.first} irb -rubygems -Ilib -rruby_parser;"
+end
+
 # vim: syntax=Ruby

data/lib/ruby_lexer.rb

@@ -847,6 +847,7 @@ class RubyLexer
                    end
 
           self.expr_beg_push "{"
+          self.command_start = true unless result == :tLBRACE
 
           return result
         elsif src.scan(/[+-]/) then
@@ -1249,7 +1250,12 @@ class RubyLexer
         if keyword then
           state           = lex_state
           self.lex_state  = keyword.state
-          self.yacc_value = token
+          self.yacc_value = [token, src.lineno]
+
+          if state == :expr_fname then
+            self.yacc_value = keyword.name
+            return keyword.id0
+          end
 
           if keyword.id0 == :kDO then
             self.command_start = true
@@ -1259,7 +1265,7 @@ class RubyLexer
             return :kDO
           end
 
-          return keyword.id0 if state == :expr_beg
+          return keyword.id0 if state == :expr_beg or state == :expr_value
 
           self.lex_state = :expr_beg if keyword.id0 != keyword.id1
 

data/lib/ruby_parser.rb

@@ -3174,19 +3174,22 @@ end
 # reduce 43 omitted
 
 def _reduce_44(val, _values, result)
-                      result = s(:return, ret_args(val[1]))
+                      line = val[0].last
+                      result = s(:return, ret_args(val[1])).line(line)
                     
     result
 end
 
 def _reduce_45(val, _values, result)
-                      result = s(:break, ret_args(val[1]))
+                      line = val[0].last
+                      result = s(:break, ret_args(val[1])).line(line)
                     
     result
 end
 
 def _reduce_46(val, _values, result)
-                      result = s(:next, ret_args(val[1]))
+                      line = val[0].last
+                      result = s(:next, ret_args(val[1])).line(line)
                     
     result
 end
@@ -4663,18 +4666,21 @@ end
 
 def _reduce_343(val, _values, result)
                       result = 0
+                      self.lexer.command_start = true
                     
     result
 end
 
 def _reduce_344(val, _values, result)
                       result = 0
+                      self.lexer.command_start = true
                     
     result
 end
 
 def _reduce_345(val, _values, result)
                       result = val[1]
+                      self.lexer.command_start = true
                     
     result
 end
@@ -5242,6 +5248,7 @@ end
 def _reduce_444(val, _values, result)
                       result = val[1]
                       lexer.lex_state = :expr_beg
+                      self.lexer.command_start = true
                     
     result
 end

data/lib/ruby_parser.y

@@ -212,15 +212,18 @@ rule
                 | block_command
                 | kRETURN call_args
                     {
-                      result = s(:return, ret_args(val[1]))
+                      line = val[0].last
+                      result = s(:return, ret_args(val[1])).line(line)
                     }
                 | kBREAK call_args
                     {
-                      result = s(:break, ret_args(val[1]))
+                      line = val[0].last
+                      result = s(:break, ret_args(val[1])).line(line)
                     }
                 | kNEXT call_args
                     {
-                      result = s(:next, ret_args(val[1]))
+                      line = val[0].last
+                      result = s(:next, ret_args(val[1])).line(line)
                     }
 
    block_command: block_call
@@ -1190,14 +1193,17 @@ rule
                 | tPIPE tPIPE
                     {
                       result = 0
+                      self.lexer.command_start = true
                     }
                 | tOROP
                     {
                       result = 0
+                      self.lexer.command_start = true
                     }
                 | tPIPE block_var tPIPE
                     {
                       result = val[1]
+                      self.lexer.command_start = true
                     }
 
         do_block: kDO_BLOCK
@@ -1596,6 +1602,7 @@ xstring_contents: none
                     {
                       result = val[1]
                       lexer.lex_state = :expr_beg
+                      self.lexer.command_start = true
                     }
                 | f_args term
                     {

data/lib/ruby_parser_extras.rb

@@ -123,7 +123,7 @@ class RPStringScanner < StringScanner
 end
 
 class RubyParser < Racc::Parser
-  VERSION = '2.2.0' unless constants.include? "VERSION" # SIGH
+  VERSION = '2.3.0' unless constants.include? "VERSION" # SIGH
 
   attr_accessor :lexer, :in_def, :in_single, :file
   attr_reader :env, :comments
@@ -506,7 +506,7 @@ class RubyParser < Racc::Parser
   end
 
   def new_defn val
-    (line, bol), name, args, body = val[2], val[1], val[3], val[4]
+    (_, line), name, args, body = val[0], val[1], val[3], val[4]
     body ||= s(:nil)
 
     body ||= s(:block)
@@ -514,7 +514,6 @@ class RubyParser < Racc::Parser
 
     result = s(:defn, name.to_sym, args, s(:scope, body))
     result.line = line
-    result.line -= 1 if bol
     result.comments = self.comments.pop
     result
   end

data/test/test_ruby_lexer.rb

@@ -1820,7 +1820,7 @@ class TestRubyLexer < MiniTest::Unit::TestCase
       token = args.shift
       value = args.shift
       assert @lex.advance, "no more tokens"
-      assert_equal [token, value], [@lex.token, @lex.yacc_value]
+      assert_equal [token, value], [@lex.token, [@lex.yacc_value].flatten.first]
     end
 
     deny @lex.advance, "must be empty, but had #{[@lex.token, @lex.yacc_value].inspect}"

data/test/test_ruby_parser.rb

@@ -32,10 +32,22 @@ class RubyParserTestCase < ParseTreeTestCase
 end
 
 class TestRubyParser < RubyParserTestCase
+  attr_accessor :result, :processor
+
   def setup
     super
 
-    @processor = RubyParser.new
+    self.processor = RubyParser.new
+  end
+
+  def assert_parse rb, pt
+    self.result = processor.parse rb
+    assert_equal pt, result
+  end
+
+  def assert_parse_line rb, pt, line
+    assert_parse rb, pt
+    assert_equal line, result.line,   "call should have line number"
   end
 
   def test_attrasgn_array_lhs
@@ -49,44 +61,42 @@ class TestRubyParser < RubyParserTestCase
                s(:call, nil, :to, s(:arglist))),
              s(:array, s(:str, "a"), s(:str, "b"), s(:str, "c"))))
 
-    result = @processor.parse(rb)
-
-    assert_equal pt, result
+    assert_parse rb, pt
   end
 
   def test_block_append
     head = s(:args)
     tail = s(:zsuper)
     expected = s(:block, s(:args), s(:zsuper))
-    assert_equal expected, @processor.block_append(head, tail)
+    assert_equal expected, processor.block_append(head, tail)
   end
 
   def test_block_append_begin_begin
     head = s(:begin, s(:args))
     tail = s(:begin, s(:args))
     expected = s(:block, s(:args), s(:begin, s(:args)))
-    assert_equal expected, @processor.block_append(head, tail)
+    assert_equal expected, processor.block_append(head, tail)
   end
 
   def test_block_append_block
     head = s(:block, s(:args))
     tail = s(:zsuper)
     expected = s(:block, s(:args), s(:zsuper))
-    assert_equal expected, @processor.block_append(head, tail)
+    assert_equal expected, processor.block_append(head, tail)
   end
 
   def test_block_append_nil_head
     head = nil
     tail = s(:zsuper)
     expected = s(:zsuper)
-    assert_equal expected, @processor.block_append(head, tail)
+    assert_equal expected, processor.block_append(head, tail)
   end
 
   def test_block_append_nil_tail
     head = s(:args)
     tail = nil
     expected = s(:args)
-    assert_equal expected, @processor.block_append(head, tail)
+    assert_equal expected, processor.block_append(head, tail)
   end
 
   def test_block_append_tail_block
@@ -95,14 +105,15 @@ class TestRubyParser < RubyParserTestCase
     expected = s(:block,
                  s(:call, nil, :f1, s(:arglist)),
                  s(:block, s(:undef, s(:lit, :x)), s(:undef, s(:lit, :y))))
-    assert_equal expected, @processor.block_append(head, tail)
+    assert_equal expected, processor.block_append(head, tail)
   end
 
   def test_call_env
-    @processor.env[:a] = :lvar
-    expected = s(:call, s(:lvar, :a), :happy, s(:arglist))
+    processor.env[:a] = :lvar
+    rb = "a.happy"
+    pt = s(:call, s(:lvar, :a), :happy, s(:arglist))
 
-    assert_equal expected, @processor.parse('a.happy')
+    assert_parse rb, pt
   end
 
   def test_dasgn_icky2
@@ -118,7 +129,7 @@ class TestRubyParser < RubyParserTestCase
                  s(:array, s(:const, :Exception), s(:lasgn, :v, s(:gvar, :$!))),
                  s(:break)))))
 
-    assert_equal pt, @processor.parse(rb)
+    assert_parse rb, pt
   end
 
   def test_class_comments
@@ -127,11 +138,10 @@ class TestRubyParser < RubyParserTestCase
            s(:scope,
              s(:defn, :blah, s(:args), s(:scope, s(:block, s(:nil))))))
 
-    actual = @processor.parse(rb)
-    assert_equal pt, actual
+    assert_parse rb, pt
 
-    assert_equal "# blah 1\n# blah 2\n\n", actual.comments
-    assert_equal "# blah 3\n", actual.scope.defn.comments
+    assert_equal "# blah 1\n# blah 2\n\n", result.comments
+    assert_equal "# blah 3\n", result.scope.defn.comments
   end
 
   def test_module_comments
@@ -140,28 +150,25 @@ class TestRubyParser < RubyParserTestCase
            s(:scope,
              s(:defn, :blah, s(:args), s(:scope, s(:block, s(:nil))))))
 
-    actual = @processor.parse(rb)
-    assert_equal pt, actual
-    assert_equal "# blah 1\n\n# blah 2\n\n", actual.comments
-    assert_equal "# blah 3\n", actual.scope.defn.comments
+    assert_parse rb, pt
+    assert_equal "# blah 1\n\n# blah 2\n\n", result.comments
+    assert_equal "# blah 3\n", result.scope.defn.comments
   end
 
   def test_defn_comments
     rb = "# blah 1\n# blah 2\n\ndef blah\nend"
     pt = s(:defn, :blah, s(:args), s(:scope, s(:block, s(:nil))))
 
-    actual = @processor.parse(rb)
-    assert_equal pt, actual
-    assert_equal "# blah 1\n# blah 2\n\n", actual.comments
+    assert_parse rb, pt
+    assert_equal "# blah 1\n# blah 2\n\n", result.comments
   end
 
   def test_defs_comments
     rb = "# blah 1\n# blah 2\n\ndef self.blah\nend"
     pt = s(:defs, s(:self), :blah, s(:args), s(:scope, s(:block)))
 
-    actual = @processor.parse(rb)
-    assert_equal pt, actual
-    assert_equal "# blah 1\n# blah 2\n\n", actual.comments
+    assert_parse rb, pt
+    assert_equal "# blah 1\n# blah 2\n\n", result.comments
   end
 
   def test_do_bug # TODO: rename
@@ -172,7 +179,7 @@ class TestRubyParser < RubyParserTestCase
              s(:call, s(:call, nil, :a, s(:arglist)), :b, s(:arglist)),
              s(:lasgn, :c)))
 
-    assert_equal pt, @processor.parse(rb)
+    assert_parse rb, pt
   end
 
   def test_bug_comment_eq_begin
@@ -180,43 +187,73 @@ class TestRubyParser < RubyParserTestCase
     pt = nil
     exp = rb.strip + "\n"
 
-    assert_equal pt, @processor.parse(rb)
-    assert_equal exp, @processor.lexer.comments
+    assert_parse rb, pt
+    assert_equal exp, processor.lexer.comments
+  end
+
+  def test_bug_call_arglist_parens
+    rb = 'g ( 1), 2'
+    pt = s(:call, nil, :g, s(:arglist, s(:lit, 1), s(:lit, 2)))
+
+    assert_parse rb, pt
+
+    rb = <<-CODE
+      def f
+        g ( 1), 2
+      end
+    CODE
+
+    pt = s(:defn, :f, s(:args),
+           s(:scope,
+             s(:block,
+               s(:call, nil, :g,
+                 s(:arglist,
+                   s(:lit, 1), s(:lit, 2))))))
+
+    assert_parse rb, pt
+
+    rb = <<-CODE
+      def f()
+        g (1), 2
+      end
+    CODE
+
+    assert_parse rb, pt
   end
 
   def test_dstr_evstr
     rb = "\"#\{'a'}#\{b}\""
     pt = s(:dstr, "a", s(:evstr, s(:call, nil, :b, s(:arglist))))
 
-    assert_equal pt, @processor.parse(rb)
+    assert_parse rb, pt
   end
 
   def test_dstr_str
     rb = "\"#\{'a'} b\""
     pt = s(:str, "a b")
 
-    assert_equal pt, @processor.parse(rb)
+    assert_parse rb, pt
   end
 
   def test_empty
     rb = ""
     pt = nil
 
-    assert_equal pt, @processor.parse(rb)
+    assert_parse rb, pt
   end
 
   def test_evstr_evstr
     rb = "\"#\{a}#\{b}\""
     pt = s(:dstr, "", s(:evstr, s(:call, nil, :a, s(:arglist))), s(:evstr, s(:call, nil, :b, s(:arglist))))
 
-    assert_equal pt, @processor.parse(rb)
+    assert_parse rb, pt
   end
 
   def test_evstr_str
     rb = "\"#\{a} b\""
     pt = s(:dstr, "", s(:evstr, s(:call, nil, :a, s(:arglist))), s(:str, " b"))
 
-    assert_equal pt, @processor.parse(rb)
+    assert_parse rb, pt
   end
 
   def test_lasgn_env
@@ -224,8 +261,8 @@ class TestRubyParser < RubyParserTestCase
     pt = s(:lasgn, :a, s(:lit, 42))
     expected_env = { :a => :lvar }
 
-    assert_equal pt, @processor.parse(rb)
-    assert_equal expected_env, @processor.env.all
+    assert_parse rb, pt
+    assert_equal expected_env, processor.env.all
   end
 
   def test_list_append
@@ -233,22 +270,22 @@ class TestRubyParser < RubyParserTestCase
     b = s(:lit, 2)
     c = s(:lit, 3)
 
-    result = @processor.list_append(s(:array, b.dup), c.dup)
+    result = processor.list_append(s(:array, b.dup), c.dup)
 
     assert_equal s(:array, b, c), result
 
-    result = @processor.list_append(b.dup, c.dup)
+    result = processor.list_append(b.dup, c.dup)
 
     assert_equal s(:array, b, c), result
 
-    result = @processor.list_append(result, a.dup)
+    result = processor.list_append(result, a.dup)
 
     assert_equal s(:array, b, c, a), result
 
     lhs, rhs = s(:array, s(:lit, :iter)), s(:when, s(:const, :BRANCHING), nil)
     expected = s(:array, s(:lit, :iter), s(:when, s(:const, :BRANCHING), nil))
 
-    assert_equal expected, @processor.list_append(lhs, rhs)
+    assert_equal expected, processor.list_append(lhs, rhs)
   end
 
   def test_list_prepend
@@ -256,15 +293,15 @@ class TestRubyParser < RubyParserTestCase
     b = s(:lit, 2)
     c = s(:lit, 3)
 
-    result = @processor.list_prepend(b.dup, s(:array, c.dup))
+    result = processor.list_prepend(b.dup, s(:array, c.dup))
 
     assert_equal s(:array, b, c), result
 
-    result = @processor.list_prepend(b.dup, c.dup)
+    result = processor.list_prepend(b.dup, c.dup)
 
     assert_equal s(:array, b, c), result
 
-    result = @processor.list_prepend(a.dup, result)
+    result = processor.list_prepend(a.dup, result)
 
     assert_equal s(:array, a, b, c), result
   end
@@ -285,27 +322,27 @@ class TestRubyParser < RubyParserTestCase
                  s(:str, "\t"),
                  s(:evstr, s(:call, s(:ivar, :@fetch_error), :message)))
 
-    assert_equal expected, @processor.literal_concat(lhs, rhs)
+    assert_equal expected, processor.literal_concat(lhs, rhs)
   end
 
   def test_literal_concat_dstr_evstr
     lhs, rhs = s(:dstr, "a"), s(:evstr, s(:call, nil, :b, s(:arglist)))
     expected = s(:dstr, "a", s(:evstr, s(:call, nil, :b, s(:arglist))))
 
-    assert_equal expected, @processor.literal_concat(lhs, rhs)
+    assert_equal expected, processor.literal_concat(lhs, rhs)
   end
 
   def test_literal_concat_evstr_evstr
     lhs, rhs = s(:evstr, s(:lit, 1)), s(:evstr, s(:lit, 2))
     expected = s(:dstr, "", s(:evstr, s(:lit, 1)), s(:evstr, s(:lit, 2)))
 
-    assert_equal expected, @processor.literal_concat(lhs, rhs)
+    assert_equal expected, processor.literal_concat(lhs, rhs)
   end
 
   def test_literal_concat_str_evstr
     lhs, rhs = s(:str, ""), s(:evstr, s(:str, "blah"))
 
-    assert_equal s(:str, "blah"), @processor.literal_concat(lhs, rhs)
+    assert_equal s(:str, "blah"), processor.literal_concat(lhs, rhs)
   end
 
   def test_logop_12
@@ -313,7 +350,7 @@ class TestRubyParser < RubyParserTestCase
     rhs = s(:lit, 2)
     exp = s(:and, s(:lit, 1), s(:lit, 2))
 
-    assert_equal exp, @processor.logop(:and, lhs, rhs)
+    assert_equal exp, processor.logop(:and, lhs, rhs)
   end
 
   def test_logop_1234_5
@@ -329,7 +366,7 @@ class TestRubyParser < RubyParserTestCase
                   s(:lit, 4),
                   s(:lit, 5)))))
 
-    assert_equal exp, @processor.logop(:and, lhs, rhs)
+    assert_equal exp, processor.logop(:and, lhs, rhs)
   end
 
   def test_logop_123_4
@@ -343,7 +380,7 @@ class TestRubyParser < RubyParserTestCase
                 s(:lit, 3),
                 s(:lit, 4))))
 
-    assert_equal exp, @processor.logop(:and, lhs, rhs)
+    assert_equal exp, processor.logop(:and, lhs, rhs)
   end
 
   def test_logop_12_3
@@ -351,7 +388,7 @@ class TestRubyParser < RubyParserTestCase
     rhs = s(:lit, 3)
     exp = s(:and, s(:lit, 1), s(:and, s(:lit, 2), s(:lit, 3)))
 
-    assert_equal exp, @processor.logop(:and, lhs, rhs)
+    assert_equal exp, processor.logop(:and, lhs, rhs)
   end
 
   def test_logop_nested_mix
@@ -364,22 +401,24 @@ class TestRubyParser < RubyParserTestCase
     lhs.paren = true
     rhs.paren = true
 
-    assert_equal exp, @processor.logop(:or, lhs, rhs)
+    assert_equal exp, processor.logop(:or, lhs, rhs)
   end
 
   def test_str_evstr
     rb = "\"a #\{b}\""
     pt = s(:dstr, "a ", s(:evstr, s(:call, nil, :b, s(:arglist))))
 
-    assert_equal pt, @processor.parse(rb)
+    assert_parse rb, pt
   end
 
   def test_dsym_to_sym
-    assert_equal(s(:alias, s(:lit, :<<), s(:lit, :>>)),
-                 @processor.parse('alias :<< :>>'))
+    pt = s(:alias, s(:lit, :<<), s(:lit, :>>))
+
+    rb = 'alias :<< :>>'
+    assert_parse rb, pt
 
-    assert_equal(s(:alias, s(:lit, :<<), s(:lit, :>>)),
-                 @processor.parse('alias :"<<" :">>"'))
+    rb = 'alias :"<<" :">>"'
+    assert_parse rb, pt
   end
 
   def test_regexp
@@ -392,7 +431,7 @@ class TestRubyParser < RubyParserTestCase
     }
 
     regexps.each do |rb, lit|
-      assert_equal s(:lit, lit), @processor.parse(rb)
+      assert_parse rb, s(:lit, lit)
     end
 
     # TODO: add more including interpolation etc
@@ -402,28 +441,29 @@ class TestRubyParser < RubyParserTestCase
     rb = "%Q[before [#\{nest}] after]"
     pt = s(:dstr, "before [", s(:evstr, s(:call, nil, :nest, s(:arglist))), s(:str, "] after"))
 
-    assert_equal pt, @processor.parse(rb)
+    assert_parse rb, pt
   end
 
-#   def test_str_pct_nested_nested
-#     rb = "%{ { #\{ \"#\{1}\" } } }"
-#     pt = s(:dstr, " { ", s(:evstr, s(:lit, 1)), s(:str, " } "))
-
-#     assert_equal pt, @processor.parse(rb)
-#   end
+  # def test_str_pct_nested_nested
+  #   rb = "%{ { #\{ \"#\{1}\" } } }"
+  #   assert_equal " { 1 } ", eval(rb)
+  #   pt = s(:dstr, " { ", s(:evstr, s(:lit, 1)), s(:str, " } "))
+  #
+  #   assert_parse rb, pt
+  # end
 
   def test_str_str
     rb = "\"a #\{'b'}\""
     pt = s(:str, "a b")
 
-    assert_equal pt, @processor.parse(rb)
+    assert_parse rb, pt
   end
 
   def test_str_str_str
     rb = "\"a #\{'b'} c\""
     pt = s(:str, "a b c")
 
-    assert_equal pt, @processor.parse(rb)
+    assert_parse rb, pt
   end
 
   STARTING_LINE = {
@@ -449,22 +489,17 @@ class TestRubyParser < RubyParserTestCase
     assert_equal expected, @result.line, "should have proper line number"
   end
 
-  def test_position_info_block
+  def test_parse_line_block
     rb = "a = 42\np a"
     pt = s(:block,
            s(:lasgn, :a, s(:lit, 42)),
            s(:call, nil, :p, s(:arglist, s(:lvar, :a))))
 
-    result = @processor.parse(rb, "blah.rb")
-
-    assert_equal pt, result
-
-    assert_equal 1, result.line,       "block should have line number"
+    assert_parse_line rb, pt, 1
     assert_equal 1, result.lasgn.line, "lasgn should have line number"
     assert_equal 2, result.call.line,  "call should have line number"
 
-    expected = "blah.rb"
-
+    expected = "(string)"
     assert_equal expected, result.file
     assert_equal expected, result.lasgn.file
     assert_equal expected, result.call.file
@@ -473,7 +508,7 @@ class TestRubyParser < RubyParserTestCase
     assert_same result.file, result.call.file
   end
 
-  def test_position_info_call_no_args
+  def test_parse_line_call_no_args
     rb = "f do |x, y|\n  x + y\nend"
 
     pt = s(:iter,
@@ -481,17 +516,41 @@ class TestRubyParser < RubyParserTestCase
            s(:masgn, s(:array, s(:lasgn, :x), s(:lasgn, :y))),
            s(:call, s(:lvar, :x), :+, s(:arglist, s(:lvar, :y))))
 
-    result = @processor.parse(rb)
-
-    assert_equal pt, result
-
+    assert_parse_line rb, pt, 1
     assert_equal 1, result[1].line,   "call should have line number"
-    assert_equal 1, result.line,      "iter should have line number"
     assert_equal 1, result[2].line,   "masgn should have line number"
     assert_equal 2, result[3].line,   "call should have line number"
   end
 
-  def test_position_info_call_parens
+  def test_parse_line_defn_no_parens
+    pt = s(:defn, :f, s(:args), s(:scope, s(:block, s(:nil))))
+
+    rb = "def f\nend"
+    assert_parse_line rb, pt, 1
+
+    rb = "def f\n\nend"
+    assert_parse_line rb, pt, 1
+  end
+
+  def test_parse_line_defn_complex
+    rb = "def x(y)\n  p(y)\n  y *= 2\n  return y;\nend" # TODO: remove () & ;
+    pt = s(:defn, :x, s(:args, :y),
+           s(:scope,
+             s(:block,
+               s(:call, nil, :p, s(:arglist, s(:lvar, :y))),
+               s(:lasgn, :y,
+                 s(:call, s(:lvar, :y), :*, s(:arglist, s(:lit, 2)))),
+               s(:return, s(:lvar, :y)))))
+
+    assert_parse_line rb, pt, 1
+
+    body = result.scope.block
+    assert_equal 2, body.call.line,   "call should have line number"
+    assert_equal 3, body.lasgn.line,  "lasgn should have line number"
+    assert_equal 4, body.return.line, "return should have line number"
+  end
+
+  def test_parse_line_iter_call_parens
     rb = "f(a) do |x, y|\n  x + y\nend"
 
     pt = s(:iter,
@@ -499,18 +558,14 @@ class TestRubyParser < RubyParserTestCase
            s(:masgn, s(:array, s(:lasgn, :x), s(:lasgn, :y))),
            s(:call, s(:lvar, :x), :+, s(:arglist, s(:lvar, :y))))
 
-    result = @processor.parse(rb)
-
-    assert_equal pt, result
+    assert_parse_line rb, pt, 1
 
     assert_equal 1, result[1].line,   "call should have line number"
-    assert_equal 1, result.line,      "iter should have line number"
     assert_equal 1, result[2].line,   "masgn should have line number"
     assert_equal 2, result[3].line,   "call should have line number"
-    # flunk "not yet"
   end
 
-  def test_position_info_call_no_parens
+  def test_parse_line_iter_call_no_parens
     rb = "f a do |x, y|\n  x + y\nend"
 
     pt = s(:iter,
@@ -518,39 +573,14 @@ class TestRubyParser < RubyParserTestCase
            s(:masgn, s(:array, s(:lasgn, :x), s(:lasgn, :y))),
            s(:call, s(:lvar, :x), :+, s(:arglist, s(:lvar, :y))))
 
-    result = @processor.parse(rb)
+    assert_parse_line rb, pt, 1
 
-    assert_equal pt, result
-
-    assert_equal 1, result.line,      "iter should have line number"
     assert_equal 1, result[1].line,   "call should have line number"
     assert_equal 1, result[2].line,   "masgn should have line number"
     assert_equal 2, result[3].line,   "call should have line number"
   end
 
-  def test_position_info_defn
-    rb = "def x(y)\n  p(y)\n  y *= 2\n  return y;\nend" # TODO: remove () & ;
-    pt = s(:defn, :x, s(:args, :y),
-           s(:scope,
-             s(:block,
-               s(:call, nil, :p, s(:arglist, s(:lvar, :y))),
-               s(:lasgn, :y,
-                 s(:call, s(:lvar, :y), :*, s(:arglist, s(:lit, 2)))),
-               s(:return, s(:lvar, :y)))))
-
-    result = @processor.parse(rb)
-
-    assert_equal pt, result
-
-    body = result.scope.block
-
-    assert_equal 1, result.line,      "defn should have line number"
-    assert_equal 2, body.call.line,   "call should have line number"
-    assert_equal 3, body.lasgn.line,  "lasgn should have line number"
-    assert_equal 4, body.return.line, "return should have line number"
-  end
-
-  def test_position_info_heredoc
+  def test_parse_line_heredoc
     rb = <<-CODE
       string = <<-HEREDOC
         very long string
@@ -558,11 +588,34 @@ class TestRubyParser < RubyParserTestCase
       puts string
     CODE
 
-    result = @processor.parse rb
+    result = processor.parse rb
     assert_equal 1, result.lasgn.line
     assert_equal 4, result.call.line
   end
 
+  def test_parse_line_return
+    rb = <<-RUBY
+      def blah
+        if true then
+          return 42
+        end
+      end
+    RUBY
+
+    pt = s(:defn, :blah, s(:args),
+           s(:scope,
+             s(:block,
+               s(:if,
+                 s(:true),
+                 s(:return, s(:lit, 42)),
+                 nil))))
+
+    assert_parse_line rb, pt, 1
+
+    assert_equal 3, result.scope.block.if.return.line
+    assert_equal 3, result.scope.block.if.return.lit.line
+  end
+
   def test_parse_if_not_canonical
     rb = "if not var.nil? then 'foo' else 'bar'\nend"
     pt = s(:if,
@@ -570,7 +623,7 @@ class TestRubyParser < RubyParserTestCase
            s(:str, "bar"),
            s(:str, "foo"))
 
-    assert_equal pt, @processor.parse(rb)
+    assert_parse rb, pt
   end
 
   def test_parse_if_not_noncanonical
@@ -581,9 +634,9 @@ class TestRubyParser < RubyParserTestCase
            s(:str, "foo"),
            s(:str, "bar"))
 
-    @processor.canonicalize_conditions = false
+    processor.canonicalize_conditions = false
 
-    assert_equal pt, @processor.parse(rb)
+    assert_parse rb, pt
   end
 
   def test_parse_while_not_canonical
@@ -592,7 +645,7 @@ class TestRubyParser < RubyParserTestCase
            s(:call, s(:call, nil, :var, s(:arglist)), :nil?, s(:arglist)),
            s(:str, "foo"), true)
 
-    assert_equal pt, @processor.parse(rb)
+    assert_parse rb, pt
   end
 
   def test_parse_while_not_noncanonical
@@ -602,9 +655,9 @@ class TestRubyParser < RubyParserTestCase
              s(:call, s(:call, nil, :var, s(:arglist)), :nil?, s(:arglist))),
            s(:str, "foo"), true)
 
-    @processor.canonicalize_conditions = false
+    processor.canonicalize_conditions = false
 
-    assert_equal pt, @processor.parse(rb)
+    assert_parse rb, pt
   end
 
   def test_parse_until_not_canonical
@@ -614,7 +667,7 @@ class TestRubyParser < RubyParserTestCase
            s(:call, s(:call, nil, :var, s(:arglist)), :nil?, s(:arglist)),
            s(:str, "foo"), true)
 
-    assert_equal pt, @processor.parse(rb)
+    assert_parse rb, pt
   end
 
   def test_parse_until_not_noncanonical
@@ -624,8 +677,8 @@ class TestRubyParser < RubyParserTestCase
              s(:call, s(:call, nil, :var, s(:arglist)), :nil?, s(:arglist))),
            s(:str, "foo"), true)
 
-    @processor.canonicalize_conditions = false
+    processor.canonicalize_conditions = false
 
-    assert_equal pt, @processor.parse(rb)
+    assert_parse rb, pt
   end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: ruby_parser
 version: !ruby/object:Gem::Version 
-  hash: 7
+  hash: 3
   prerelease: 
   segments: 
   - 2
-  - 2
+  - 3
   - 0
-  version: 2.2.0
+  version: 2.3.0
 platform: ruby
 authors: 
 - Ryan Davis
@@ -36,7 +36,7 @@ cert_chain:
   FBHgymkyj/AOSqKRIpXPhjC6
   -----END CERTIFICATE-----
 
-date: 2011-08-23 00:00:00 Z
+date: 2011-09-06 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: sexp_processor
@@ -181,7 +181,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: parsetree
-rubygems_version: 1.8.8
+rubygems_version: 1.8.10
 signing_key: 
 specification_version: 3
 summary: ruby_parser (RP) is a ruby parser written in pure ruby (utilizing racc--which does by default use a C extension)