ripper_ruby_parser 1.1.2 → 1.2.0

data/test/end_to_end/line_numbering_test.rb

@@ -2,7 +2,7 @@ require File.expand_path('../test_helper.rb', File.dirname(__FILE__))
 require 'ruby_parser'
 
 describe 'Using RipperRubyParser and RubyParser' do
-  def to_line_numbers exp
+  def to_line_numbers(exp)
     exp.map! do |sub_exp|
       if sub_exp.is_a? Sexp
         to_line_numbers sub_exp

data/test/end_to_end/samples_comparison_test.rb

@@ -21,7 +21,6 @@ describe 'Using RipperRubyParser and RubyParser' do
       end
 
       let :imitation do
-        newparser.extra_compatible = true
         newparser.parse program
       end
 

data/test/pt_testcase/pt_test.rb

@@ -2,7 +2,7 @@ require File.expand_path('../test_helper.rb', File.dirname(__FILE__))
 require 'pt_testcase'
 
 class TestParser < RipperRubyParser::Parser
-  def process input
+  def process(input)
     parse input
   end
 end
@@ -10,11 +10,11 @@ end
 SKIPPED_TESTS = ['dstr_heredoc_windoze_sucks'].freeze
 
 class RubyParserTestCase < ParseTreeTestCase
-  def self.previous _key
+  def self.previous(_key)
     'Ruby'
   end
 
-  def self.generate_test klass, node, data, input_name, output_name
+  def self.generate_test(klass, node, data, input_name, _output_name)
     if data['Ruby'].is_a? Array
       klass.send :define_method, "test_#{node}" do
         skip 'Not a parser test'
@@ -29,9 +29,7 @@ class RubyParserTestCase < ParseTreeTestCase
       return
     end
 
-    output_name = 'ParseTree'
-
-    super
+    super klass, node, data, input_name, 'ParseTree'
   end
 end
 

data/test/{unit → ripper_ruby_parser}/commenting_ripper_parser_test.rb

@@ -1,119 +1,176 @@
 require File.expand_path('../test_helper.rb', File.dirname(__FILE__))
 
 describe RipperRubyParser::CommentingRipperParser do
-  def parse_with_builder str
+  def parse_with_builder(str)
     builder = RipperRubyParser::CommentingRipperParser.new str
     builder.parse
   end
 
   def empty_params_list
-    @empty_params_list ||= begin
-                             num_params = RUBY_VERSION < '2.0.0' ? 5 : 7
-                             s(:params, *([nil] * num_params))
-                           end
+    @empty_params_list ||= s(:params, *([nil] * 7))
   end
 
   describe 'handling comments' do
     it 'produces a comment node surrounding a commented def' do
       result = parse_with_builder "# Foo\ndef foo; end"
       result.must_equal s(:program,
-                          s(s(:comment,
+                          s(:stmts,
+                            s(:comment,
                               "# Foo\n",
                               s(:def,
                                 s(:@ident, 'foo', s(2, 4)),
                                 empty_params_list,
-                                s(:bodystmt, s(s(:void_stmt)), nil, nil, nil)))))
+                                s(:bodystmt, s(:stmts, s(:void_stmt)), nil, nil, nil)))))
     end
 
     it 'produces a blank comment node surrounding a def that has no comment' do
       result = parse_with_builder 'def foo; end'
       result.must_equal s(:program,
-                          s(s(:comment,
+                          s(:stmts,
+                            s(:comment,
                               '',
                               s(:def,
                                 s(:@ident, 'foo', s(1, 4)),
                                 empty_params_list,
-                                s(:bodystmt, s(s(:void_stmt)), nil, nil, nil)))))
+                                s(:bodystmt, s(:stmts, s(:void_stmt)), nil, nil, nil)))))
     end
 
     it 'produces a comment node surrounding a commented class' do
       result = parse_with_builder "# Foo\nclass Foo; end"
       result.must_equal s(:program,
-                          s(s(:comment,
+                          s(:stmts,
+                            s(:comment,
                               "# Foo\n",
                               s(:class,
                                 s(:const_ref, s(:@const, 'Foo', s(2, 6))),
                                 nil,
-                                s(:bodystmt, s(s(:void_stmt)), nil, nil, nil)))))
+                                s(:bodystmt, s(:stmts, s(:void_stmt)), nil, nil, nil)))))
     end
 
     it 'produce a blank comment node surrounding a class that has no comment' do
       result = parse_with_builder 'class Foo; end'
       result.must_equal s(:program,
-                          s(s(:comment,
+                          s(:stmts,
+                            s(:comment,
                               '',
                               s(:class,
                                 s(:const_ref, s(:@const, 'Foo', s(1, 6))),
                                 nil,
-                                s(:bodystmt, s(s(:void_stmt)), nil, nil, nil)))))
+                                s(:bodystmt, s(:stmts, s(:void_stmt)), nil, nil, nil)))))
     end
 
     it 'produces a comment node surrounding a commented module' do
       result = parse_with_builder "# Foo\nmodule Foo; end"
       result.must_equal s(:program,
-                          s(s(:comment,
+                          s(:stmts,
+                            s(:comment,
                               "# Foo\n",
                               s(:module,
                                 s(:const_ref, s(:@const, 'Foo', s(2, 7))),
-                                s(:bodystmt, s(s(:void_stmt)), nil, nil, nil)))))
+                                s(:bodystmt, s(:stmts, s(:void_stmt)), nil, nil, nil)))))
     end
 
     it 'produces a blank comment node surrounding a module that has no comment' do
       result = parse_with_builder 'module Foo; end'
       result.must_equal s(:program,
-                          s(s(:comment,
+                          s(:stmts,
+                            s(:comment,
                               '',
                               s(:module,
                                 s(:const_ref, s(:@const, 'Foo', s(1, 7))),
-                                s(:bodystmt, s(s(:void_stmt)), nil, nil, nil)))))
+                                s(:bodystmt, s(:stmts, s(:void_stmt)), nil, nil, nil)))))
     end
 
     it 'is not confused by a symbol containing a keyword' do
       result = parse_with_builder ':class; def foo; end'
       result.must_equal s(:program,
-                          s(s(:symbol_literal, s(:symbol, s(:@kw, 'class', s(1, 1)))),
+                          s(:stmts,
+                            s(:symbol_literal, s(:symbol, s(:@kw, 'class', s(1, 1)))),
                             s(:comment,
                               '',
                               s(:def,
                                 s(:@ident, 'foo', s(1, 12)),
                                 empty_params_list,
-                                s(:bodystmt, s(s(:void_stmt)), nil, nil, nil)))))
+                                s(:bodystmt, s(:stmts, s(:void_stmt)), nil, nil, nil)))))
     end
 
     it 'is not confused by a dynamic symbol' do
       result = parse_with_builder ":'foo'; def bar; end"
       result.must_equal s(:program,
-                          s(s(:dyna_symbol, s(s(:@tstring_content, 'foo', s(1, 2)))),
+                          s(:stmts,
+                            s(:dyna_symbol,
+                              s(:xstring, s(:@tstring_content, 'foo', s(1, 2)))),
                             s(:comment,
                               '',
                               s(:def,
                                 s(:@ident, 'bar', s(1, 12)),
                                 empty_params_list,
-                                s(:bodystmt, s(s(:void_stmt)), nil, nil, nil)))))
+                                s(:bodystmt, s(:stmts, s(:void_stmt)), nil, nil, nil)))))
     end
 
     it 'is not confused by a dynamic symbol containing a class definition' do
       result = parse_with_builder ":\"foo\#{class Bar;end}\""
       result.must_equal s(:program,
-                          s(s(:dyna_symbol,
-                              s(s(:@tstring_content, 'foo', s(1, 2)),
+                          s(:stmts,
+                            s(:dyna_symbol,
+                              s(:xstring,
+                                s(:@tstring_content, 'foo', s(1, 2)),
                                 s(:string_embexpr,
-                                  s(s(:comment,
+                                  s(:stmts,
+                                    s(:comment,
                                       '',
                                       s(:class,
                                         s(:const_ref, s(:@const, 'Bar', s(1, 13))),
                                         nil,
-                                        s(:bodystmt, s(s(:void_stmt)), nil, nil, nil)))))))))
+                                        s(:bodystmt,
+                                          s(:stmts, s(:void_stmt)),
+                                          nil,
+                                          nil,
+                                          nil)))))))))
+    end
+  end
+
+  describe 'handling syntax errors' do
+    it 'raises an error for an incomplete source' do
+      proc {
+        parse_with_builder 'def foo'
+      }.must_raise RipperRubyParser::SyntaxError
+    end
+
+    it 'raises an error for an invalid class name' do
+      proc {
+        parse_with_builder 'class foo; end'
+      }.must_raise RipperRubyParser::SyntaxError
+    end
+
+    it 'raises an error aliasing $1 as foo' do
+      proc {
+        parse_with_builder 'alias foo $1'
+      }.must_raise RipperRubyParser::SyntaxError
+    end
+
+    it 'raises an error aliasing foo as $1' do
+      proc {
+        parse_with_builder 'alias $1 foo'
+      }.must_raise RipperRubyParser::SyntaxError
+    end
+
+    it 'raises an error aliasing $2 as $1' do
+      proc {
+        parse_with_builder 'alias $1 $2'
+      }.must_raise RipperRubyParser::SyntaxError
+    end
+
+    it 'raises an error assigning to $1' do
+      proc {
+        parse_with_builder '$1 = foo'
+      }.must_raise RipperRubyParser::SyntaxError
+    end
+
+    it 'raises an error using an invalid parameter name' do
+      proc {
+        parse_with_builder 'def foo(BAR); end'
+      }.must_raise RipperRubyParser::SyntaxError
     end
   end
 end

data/test/{unit → ripper_ruby_parser}/parser_test.rb

@@ -8,19 +8,6 @@ describe RipperRubyParser::Parser do
       result.must_be_instance_of Sexp
     end
 
-    it 'post-processes its result with the passed sexp processor' do
-      sexp_p = MiniTest::Mock.new
-      sexp_p.expect :process, s(:result), [Sexp]
-      sexp_p.expect :filename=, nil, ['(string)']
-      sexp_p.expect :extra_compatible=, nil, [false]
-
-      parser = RipperRubyParser::Parser.new sexp_p
-      result = parser.parse 'any code'
-
-      result.must_equal s(:result)
-      sexp_p.verify
-    end
-
     describe 'for an empty program' do
       it 'returns nil' do
         ''.must_be_parsed_as nil
@@ -48,7 +35,7 @@ describe RipperRubyParser::Parser do
       end
     end
 
-    describe 'for empty brackets' do
+    describe 'for empty parentheses' do
       it 'works with lone ()' do
         '()'.must_be_parsed_as s(:nil)
       end
@@ -293,7 +280,7 @@ describe RipperRubyParser::Parser do
                               s(:nil))
       end
 
-      it 'works with brackets around the parameter list' do
+      it 'works with parentheses around the parameter list' do
         'def foo(bar); end'.
           must_be_parsed_as s(:defn, :foo, s(:args, :bar), s(:nil))
       end
@@ -390,7 +377,6 @@ describe RipperRubyParser::Parser do
       end
 
       it 'works with a named argument with no default value' do
-        skip 'Default values are required in Ruby 2.0' if RUBY_VERSION < '2.1.0'
         'def foo bar:; end'.
           must_be_parsed_as s(:defn,
                               :foo,
@@ -414,181 +400,35 @@ describe RipperRubyParser::Parser do
       end
     end
 
-    describe 'for blocks' do
-      it 'works with no statements in the block body' do
-        'foo do; end'.
-          must_be_parsed_as s(:iter,
-                              s(:call, nil, :foo),
-                              0)
-      end
-
-      it 'works with next with no arguments' do
-        'foo do; next; end'.
-          must_be_parsed_as s(:iter,
-                              s(:call, nil, :foo),
-                              0,
-                              s(:next))
-      end
-
-      it 'works with next with one argument' do
-        'foo do; next bar; end'.
-          must_be_parsed_as s(:iter,
-                              s(:call, nil, :foo),
-                              0,
-                              s(:next, s(:call, nil, :bar)))
-      end
-
-      it 'works with next with several arguments' do
-        'foo do; next bar, baz; end'.
-          must_be_parsed_as s(:iter,
-                              s(:call, nil, :foo),
-                              0,
-                              s(:next,
-                                s(:array,
-                                  s(:call, nil, :bar),
-                                  s(:call, nil, :baz))))
-      end
-
-      it 'works with next with a function call with parentheses' do
-        'foo do; next foo(bar); end'.
-          must_be_parsed_as s(:iter,
-                              s(:call, nil, :foo),
-                              0,
-                              s(:next,
-                                s(:call, nil, :foo,
-                                  s(:call, nil, :bar))))
-      end
-
-      it 'works with next with a function call without parentheses' do
-        'foo do; next foo bar; end'.
-          must_be_parsed_as s(:iter,
-                              s(:call, nil, :foo),
-                              0,
-                              s(:next,
-                                s(:call, nil, :foo,
-                                  s(:call, nil, :bar))))
-      end
-
-      it 'works with break with no arguments' do
-        'foo do; break; end'.
-          must_be_parsed_as s(:iter,
-                              s(:call, nil, :foo),
-                              0,
-                              s(:break))
-      end
-
-      it 'works with break with one argument' do
-        'foo do; break bar; end'.
-          must_be_parsed_as s(:iter,
-                              s(:call, nil, :foo),
-                              0,
-                              s(:break, s(:call, nil, :bar)))
-      end
-
-      it 'works with break with several arguments' do
-        'foo do; break bar, baz; end'.
-          must_be_parsed_as s(:iter,
-                              s(:call, nil, :foo),
-                              0,
-                              s(:break,
-                                s(:array,
-                                  s(:call, nil, :bar),
-                                  s(:call, nil, :baz))))
-      end
-
-      it 'works with break with a function call with parentheses' do
-        'foo do; break foo(bar); end'.
-          must_be_parsed_as s(:iter,
-                              s(:call, nil, :foo),
-                              0,
-                              s(:break,
-                                s(:call, nil, :foo,
-                                  s(:call, nil, :bar))))
-      end
-
-      it 'works with break with a function call without parentheses' do
-        'foo do; break foo bar; end'.
-          must_be_parsed_as s(:iter,
-                              s(:call, nil, :foo),
-                              0,
-                              s(:break,
-                                s(:call, nil, :foo,
-                                  s(:call, nil, :bar))))
-      end
-
-      it 'works with redo' do
-        'foo do; redo; end'.
-          must_be_parsed_as s(:iter,
-                              s(:call, nil, :foo),
-                              0,
-                              s(:redo))
-      end
-
-      it 'works with zero arguments' do
-        'foo do ||; end'.
-          must_be_parsed_as s(:iter,
-                              s(:call, nil, :foo),
-                              s(:args))
-      end
-
-      it 'works with one argument' do
-        'foo do |bar|; end'.
-          must_be_parsed_as s(:iter,
-                              s(:call, nil, :foo),
-                              s(:args, :bar))
-      end
-
-      it 'works with multiple arguments' do
-        'foo do |bar, baz|; end'.
-          must_be_parsed_as s(:iter,
-                              s(:call, nil, :foo),
-                              s(:args, :bar, :baz))
-      end
-
-      it 'works with a single splat argument' do
-        'foo do |*bar|; end'.
-          must_be_parsed_as s(:iter,
-                              s(:call, nil, :foo),
-                              s(:args, :"*bar"))
-      end
-
-      it 'works with a combination of regular arguments and a splat argument' do
-        'foo do |bar, *baz|; end'.
-          must_be_parsed_as s(:iter,
-                              s(:call, nil, :foo),
-                              s(:args, :bar, :"*baz"))
-      end
-    end
-
     describe 'for yield' do
-      it 'works with no arguments and no brackets' do
+      it 'works with no arguments and no parentheses' do
         'yield'.
           must_be_parsed_as s(:yield)
       end
 
-      it 'works with brackets but no arguments' do
+      it 'works with parentheses but no arguments' do
         'yield()'.
           must_be_parsed_as s(:yield)
       end
 
-      it 'works with one argument and no brackets' do
+      it 'works with one argument and no parentheses' do
         'yield foo'.
           must_be_parsed_as s(:yield, s(:call, nil, :foo))
       end
 
-      it 'works with one argument and brackets' do
+      it 'works with one argument and parentheses' do
         'yield(foo)'.
           must_be_parsed_as s(:yield, s(:call, nil, :foo))
       end
 
-      it 'works with multiple arguments and no brackets' do
+      it 'works with multiple arguments and no parentheses' do
         'yield foo, bar'.
           must_be_parsed_as s(:yield,
                               s(:call, nil, :foo),
                               s(:call, nil, :bar))
       end
 
-      it 'works with multiple arguments and brackets' do
+      it 'works with multiple arguments and parentheses' do
         'yield(foo, bar)'.
           must_be_parsed_as s(:yield,
                               s(:call, nil, :foo),
@@ -617,6 +457,13 @@ describe RipperRubyParser::Parser do
       end
     end
 
+    describe 'for the __ENCODING__ keyword' do
+      it 'evaluates to the equivalent of Encoding::UTF_8' do
+        '__ENCODING__'.
+          must_be_parsed_as s(:colon2, s(:const, :Encoding), :UTF_8)
+      end
+    end
+
     describe 'for the __FILE__ keyword' do
       describe 'when not passing a file name' do
         it "creates a string sexp with value '(string)'" do
@@ -871,7 +718,7 @@ describe RipperRubyParser::Parser do
                                 s(:call, nil, :qux)))
       end
 
-      it 'works with brackets around the left-hand side' do
+      it 'works with parentheses around the left-hand side' do
         '(foo, bar) = baz'.
           must_be_parsed_as s(:masgn,
                               s(:array, s(:lasgn, :foo), s(:lasgn, :bar)),
@@ -1167,7 +1014,7 @@ describe RipperRubyParser::Parser do
         result.line.must_equal 1
       end
 
-      it 'works for a method call with brackets' do
+      it 'works for a method call with parentheses' do
         result = parser.parse 'foo()'
         result.line.must_equal 1
       end
@@ -1308,4 +1155,24 @@ describe RipperRubyParser::Parser do
       end
     end
   end
+
+  describe '#trickle_up_line_numbers' do
+    it 'works through several nested levels' do
+      inner = s(:foo)
+      outer = s(:bar, s(:baz, s(:qux, inner)))
+      outer.line = 42
+      parser.send :trickle_down_line_numbers, outer
+      inner.line.must_equal 42
+    end
+  end
+
+  describe '#trickle_down_line_numbers' do
+    it 'works through several nested levels' do
+      inner = s(:foo)
+      inner.line = 42
+      outer = s(:bar, s(:baz, s(:qux, inner)))
+      parser.send :trickle_up_line_numbers, outer
+      outer.line.must_equal 42
+    end
+  end
 end