parser 2.0.0.beta6 → 2.0.0.beta7

data/lib/parser/runner/ruby_parse.rb

@@ -11,15 +11,15 @@ module Parser
           p node
 
           source_line_no = nil
-          source_line    = ""
-          hilight_line   = ""
+          source_line    = ''
+          hilight_line   = ''
 
           print_line = lambda do
             unless hilight_line.empty?
               puts hilight_line.
                 gsub(/[a-z_]+/) { |m| "\e[1;33m#{m}\e[0m" }.
                 gsub(/[~.]+/)   { |m| "\e[1;35m#{m}\e[0m" }
-              hilight_line = ""
+              hilight_line = ''
             end
           end
 

data/lib/parser/runner/ruby_rewrite.rb

@@ -54,7 +54,7 @@ module Parser
         new_ast = @parser.parse(new_buffer)
 
         unless ast == new_ast
-          $stderr.puts "ASTs do not match:"
+          $stderr.puts 'ASTs do not match:'
 
           old = Tempfile.new('old')
           old.write ast.inspect + "\n"; old.flush

data/lib/parser/source/buffer.rb

@@ -7,7 +7,7 @@ module Parser
       attr_reader :name, :first_line
 
       def self.recognize_encoding(string)
-        return Encoding::UTF_8 if string.empty?
+        return if string.empty?
 
         # extract the first two lines in an efficient way
         string =~ /(.*)\n?(.*\n)?/
@@ -28,7 +28,7 @@ module Parser
         if encoding_line =~ /^#.*coding\s*[:=]\s*([A-Za-z0-9_-]+)/
           Encoding.find($1)
         else
-          Encoding::UTF_8
+          nil
         end
       end
 
@@ -39,13 +39,15 @@ module Parser
       def self.reencode_string(string)
         encoding = recognize_encoding(string)
 
-        unless encoding.ascii_compatible?
-          raise RuntimeError, "Encoding #{encoding} is not ASCII-compatible"
+        if encoding.nil?
+          string
+        elsif encoding == Encoding::BINARY
+          string.force_encoding(Encoding::BINARY)
+        else
+          string.
+            force_encoding(encoding).
+            encode(Encoding::UTF_8)
         end
-
-        string.
-          force_encoding(encoding).
-          encode(Encoding::UTF_8)
       end
 
       def initialize(name, first_line = 1)
@@ -75,7 +77,7 @@ module Parser
 
       def source=(source)
         if @source
-          raise ArgumentError, "Source::Buffer is immutable"
+          raise ArgumentError, 'Source::Buffer is immutable'
         end
 
         if source.respond_to? :encoding

data/lib/parser/source/rewriter.rb

@@ -16,7 +16,7 @@ module Parser
       end
 
       def remove(range)
-        append Rewriter::Action.new(range, "")
+        append Rewriter::Action.new(range, '')
       end
 
       def insert_before(range, content)

data/lib/parser/source/rewriter/action.rb

@@ -4,7 +4,7 @@ module Parser
     class Rewriter::Action
       attr_reader :range, :replacement
 
-      def initialize(range, replacement="")
+      def initialize(range, replacement='')
         @range, @replacement = range, replacement
 
         freeze
@@ -12,7 +12,7 @@ module Parser
 
       def to_s
         if @range.length == 0 && @replacement.empty?
-          "do nothing"
+          'do nothing'
         elsif @range.length == 0
           "insert #{@replacement.inspect}"
         elsif @replacement.empty?

data/lib/parser/version.rb

@@ -1,3 +1,3 @@
 module Parser
-  VERSION = '2.0.0.beta6'
+  VERSION = '2.0.0.beta7'
 end

data/test/helper.rb

@@ -23,12 +23,12 @@ if SimpleCov.usable?
       Coveralls::SimpleCov::Formatter
     ]
 
-    add_group "Grammars" do |source_file|
+    add_group 'Grammars' do |source_file|
       source_file.filename =~ %r{\.y$}
     end
 
     # Exclude the testsuite itself.
-    add_filter "/test/"
+    add_filter '/test/'
 
     # Exclude generated files.
     add_filter do |source_file|

data/test/parse_helper.rb

@@ -20,10 +20,10 @@ module ParseHelper
 
   def parser_for_ruby_version(version)
     case version
-    when '1.8'; parser = Parser::Ruby18.new
-    when '1.9'; parser = Parser::Ruby19.new
-    when '2.0'; parser = Parser::Ruby20.new
-    when '2.1'; parser = Parser::Ruby21.new
+    when '1.8' then parser = Parser::Ruby18.new
+    when '1.9' then parser = Parser::Ruby19.new
+    when '2.0' then parser = Parser::Ruby20.new
+    when '2.1' then parser = Parser::Ruby21.new
     else raise "Unrecognized Ruby version #{version}"
     end
 
@@ -143,7 +143,7 @@ module ParseHelper
         when 'location'
           assert_source_range begin_pos, end_pos,
                               emitted_diagnostic.location,
-                              version, "location"
+                              version, 'location'
 
         when 'highlights'
           index = ast_path.first.to_i

data/test/test_diagnostic.rb

@@ -3,7 +3,7 @@ require 'helper'
 class TestDiagnostic < Minitest::Test
   def setup
     @buffer = Parser::Source::Buffer.new('(string)')
-    @buffer.source = "if (this is some bad code + bugs)"
+    @buffer.source = 'if (this is some bad code + bugs)'
 
     @range1 = Parser::Source::Range.new(@buffer, 0, 2) # if
     @range2 = Parser::Source::Range.new(@buffer, 4, 8) # this
@@ -11,12 +11,12 @@ class TestDiagnostic < Minitest::Test
 
   def test_verifies_levels
     assert_raises ArgumentError, /level/ do
-      Parser::Diagnostic.new(:foobar, "foo", @range1)
+      Parser::Diagnostic.new(:foobar, 'foo', @range1)
     end
   end
 
   def test_freezes
-    string     = "foo"
+    string     = 'foo'
     highlights = [@range2]
 
     diag = Parser::Diagnostic.new(:error, string, @range1, highlights)
@@ -36,12 +36,12 @@ class TestDiagnostic < Minitest::Test
       Parser::Source::Range.new(@buffer, 28, 32)
     ]
 
-    diag  = Parser::Diagnostic.new(:error, "code far too bad",
+    diag  = Parser::Diagnostic.new(:error, 'code far too bad',
                                    location, highlights)
     assert_equal([
-      "(string):1:27: error: code far too bad",
-      "if (this is some bad code + bugs)",
-      "                     ~~~~ ^ ~~~~ "
+      '(string):1:27: error: code far too bad',
+      'if (this is some bad code + bugs)',
+      '                     ~~~~ ^ ~~~~ '
     ], diag.render)
   end
 end

data/test/test_diagnostic_engine.rb

@@ -12,7 +12,7 @@ class TestDiagnosticEngine < Minitest::Test
   end
 
   def test_process_warnings
-    warn = Parser::Diagnostic.new(:warning, "foo", @buffer, 1..2)
+    warn = Parser::Diagnostic.new(:warning, 'foo', @buffer, 1..2)
     @engine.process(warn)
 
     assert_equal [warn], @queue
@@ -21,7 +21,7 @@ class TestDiagnosticEngine < Minitest::Test
   def test_ignore_warnings
     @engine.ignore_warnings = true
 
-    warn = Parser::Diagnostic.new(:warning, "foo", @buffer, 1..2)
+    warn = Parser::Diagnostic.new(:warning, 'foo', @buffer, 1..2)
     @engine.process(warn)
 
     assert_equal [], @queue
@@ -30,7 +30,7 @@ class TestDiagnosticEngine < Minitest::Test
   def test_all_errors_are_fatal
     @engine.all_errors_are_fatal = true
 
-    error = Parser::Diagnostic.new(:error, "foo", @buffer, 1..2)
+    error = Parser::Diagnostic.new(:error, 'foo', @buffer, 1..2)
 
     assert_raises Parser::SyntaxError do
       @engine.process(error)
@@ -40,14 +40,14 @@ class TestDiagnosticEngine < Minitest::Test
   end
 
   def test_all_errors_are_collected
-    error = Parser::Diagnostic.new(:error, "foo", @buffer, 1..2)
+    error = Parser::Diagnostic.new(:error, 'foo', @buffer, 1..2)
     @engine.process(error)
 
     assert_equal [error], @queue
   end
 
   def test_fatal_error
-    fatal = Parser::Diagnostic.new(:fatal, "foo", @buffer, 1..2)
+    fatal = Parser::Diagnostic.new(:fatal, 'foo', @buffer, 1..2)
 
     assert_raises Parser::SyntaxError do
       @engine.process(fatal)

data/test/test_encoding.rb

@@ -9,7 +9,7 @@ class TestEncoding < Minitest::Test
 
   if defined?(Encoding)
     def test_default
-      assert_equal Encoding::UTF_8, recognize("foobar")
+      assert_equal nil, recognize('foobar')
     end
 
     def test_bom
@@ -26,24 +26,24 @@ class TestEncoding < Minitest::Test
     end
 
     def test_case
-      assert_equal Encoding::KOI8_R, recognize("#!/bin/foo\n# coding:KoI8-r\nfoobar")
+      assert_equal Encoding::KOI8_R, recognize("# coding:KoI8-r\nfoobar")
     end
 
     def test_space
-      assert_equal Encoding::KOI8_R, recognize("#!/bin/foo\n# coding : koi8-r\nfoobar")
+      assert_equal Encoding::KOI8_R, recognize("# coding : koi8-r\nfoobar")
     end
 
     def test_empty
-      assert_equal Encoding::UTF_8, recognize("")
+      assert_equal nil, recognize('')
     end
 
     def test_no_comment
-      assert_equal Encoding::UTF_8, recognize(%{require 'cane/encoding_aware_iterator'})
+      assert_equal nil, recognize(%{require 'cane/encoding_aware_iterator'})
     end
 
     def test_adjacent
-      assert_equal Encoding::UTF_8, recognize("# codingkoi8-r")
-      assert_equal Encoding::UTF_8, recognize("# coding koi8-r")
+      assert_equal nil, recognize('# codingkoi8-r')
+      assert_equal nil, recognize('# coding koi8-r')
     end
   end
 end

data/test/test_lexer.rb

@@ -2417,14 +2417,14 @@ class TestLexer < Minitest::Test
   def test_bug_expr_beg_document
     @lex.state = :expr_beg
     util_lex_token(" \n=begin\n=end\nend",
-                   :kEND,        "end")
+                   :kEND,            "end")
 
   end
 
   def test_bug_expr_beg_number
     @lex.state = :expr_beg
     util_lex_token("86400_000_000",
-                   :tINTEGER,    86400000000)
+                   :tINTEGER,        86400_000_000)
   end
 
   def test_bug_expr_beg_backspace_nl

data/test/test_parse_helper.rb

@@ -58,7 +58,7 @@ class TestParseHelper < Minitest::Test
     ast = s(:send,
             s(:int, 1), :+,
             s(:dstr,
-              s(:str, "foo"),
+              s(:str, 'foo'),
               s(:int, 2),
               s(:int, 3)))
 
@@ -67,7 +67,7 @@ class TestParseHelper < Minitest::Test
     assert_equal s(:int, 1), traverse_ast(ast, %w(int))
     assert_equal nil, traverse_ast(ast, %w(str))
 
-    assert_equal s(:str, "foo"), traverse_ast(ast, %w(dstr str))
+    assert_equal s(:str, 'foo'), traverse_ast(ast, %w(dstr str))
     assert_equal s(:int, 2), traverse_ast(ast, %w(dstr int))
     assert_equal s(:int, 2), traverse_ast(ast, %w(dstr int/1))
     assert_equal s(:int, 3), traverse_ast(ast, %w(dstr int/2))

data/test/test_parser.rb

@@ -53,6 +53,22 @@ class TestParser < Minitest::Test
       %q{~~~ expression})
   end
 
+  def test_nil_expression
+    assert_parses(
+      s(:begin),
+      %q{()},
+      %q{^ begin
+        | ^ end
+        |~~ expression})
+
+    assert_parses(
+      s(:kwbegin),
+      %q{begin end},
+      %q{~~~~~ begin
+        |      ~~~ end
+        |~~~~~~~~~ expression})
+  end
+
   def test_true
     assert_parses(
       s(:true),
@@ -325,7 +341,7 @@ class TestParser < Minitest::Test
 
   def test_array_words
     assert_parses(
-      s(:array, s(:str, "foo"), s(:str, "bar")),
+      s(:array, s(:str, 'foo'), s(:str, 'bar')),
       %q{%w[foo bar]},
       %q{^^^ begin
         |          ^ end
@@ -336,7 +352,7 @@ class TestParser < Minitest::Test
   def test_array_words_interp
     assert_parses(
       s(:array,
-        s(:str, "foo"),
+        s(:str, 'foo'),
         s(:dstr, s(:begin, s(:lvar, :bar)))),
       %q{%W[foo #{bar}]},
       %q{^^^ begin
@@ -350,7 +366,7 @@ class TestParser < Minitest::Test
 
     assert_parses(
       s(:array,
-        s(:str, "foo"),
+        s(:str, 'foo'),
         s(:dstr,
           s(:begin, s(:lvar, :bar)),
           s(:str, 'foo'),
@@ -401,7 +417,7 @@ class TestParser < Minitest::Test
     assert_parses(
       s(:array,
         s(:dsym,
-          s(:str, "foo"),
+          s(:str, 'foo'),
           s(:begin, s(:lvar, :bar)))),
       %q{%I[foo#{bar}]},
       %q{},
@@ -1490,7 +1506,7 @@ class TestParser < Minitest::Test
       s(:undef,
         s(:sym, :foo),
         s(:sym, :bar),
-        s(:dsym, s(:str, "foo"), s(:begin, s(:int, 1)))),
+        s(:dsym, s(:str, 'foo'), s(:begin, s(:int, 1)))),
       %q{undef foo, :bar, :"foo#{1}"},
       %q{~~~~~ keyword
         |      ~~~ expression (sym/1)
@@ -1539,8 +1555,8 @@ class TestParser < Minitest::Test
     assert_parses(
       s(:def, :f,
         s(:args, s(:arg, :foo)),
-        s(:nil)),
-      %q{def f(foo); nil; end},
+        nil),
+      %q{def f(foo); end},
       %q{      ~~~ name (args.arg)
         |      ~~~ expression (args.arg)
         |     ^ begin (args)
@@ -1550,16 +1566,16 @@ class TestParser < Minitest::Test
     assert_parses(
       s(:def, :f,
         s(:args, s(:arg, :foo), s(:arg, :bar)),
-        s(:nil)),
-      %q{def f(foo, bar); nil; end})
+        nil),
+      %q{def f(foo, bar); end})
   end
 
   def test_optarg
     assert_parses(
       s(:def, :f,
         s(:args, s(:optarg, :foo, s(:int, 1))),
-        s(:nil)),
-      %q{def f foo = 1; nil; end},
+        nil),
+      %q{def f foo = 1; end},
       %q{      ~~~ name (args.optarg)
         |          ^ operator (args.optarg)
         |      ~~~~~~~ expression (args.optarg)
@@ -1570,16 +1586,16 @@ class TestParser < Minitest::Test
         s(:args,
           s(:optarg, :foo, s(:int, 1)),
           s(:optarg, :bar, s(:int, 2))),
-        s(:nil)),
-      %q{def f(foo=1, bar=2); nil; end})
+        nil),
+      %q{def f(foo=1, bar=2); end})
   end
 
   def test_restarg_named
     assert_parses(
       s(:def, :f,
         s(:args, s(:restarg, :foo)),
-        s(:nil)),
-      %q{def f(*foo); nil; end},
+        nil),
+      %q{def f(*foo); end},
       %q{       ~~~ name (args.restarg)
         |      ~~~~ expression (args.restarg)})
   end
@@ -1588,8 +1604,8 @@ class TestParser < Minitest::Test
     assert_parses(
       s(:def, :f,
         s(:args, s(:restarg)),
-        s(:nil)),
-      %q{def f(*); nil; end},
+        nil),
+      %q{def f(*); end},
       %q{      ~ expression (args.restarg)})
   end
 
@@ -1597,8 +1613,8 @@ class TestParser < Minitest::Test
     assert_parses(
       s(:def, :f,
         s(:args, s(:kwarg, :foo)),
-        s(:nil)),
-      %q{def f(foo:); nil; end},
+        nil),
+      %q{def f(foo:); end},
       %q{      ~~~ name (args.kwarg)
         |      ~~~~ expression (args.kwarg)},
       ALL_VERSIONS - %w(1.8 1.9 2.0))
@@ -1608,8 +1624,8 @@ class TestParser < Minitest::Test
     assert_parses(
       s(:def, :f,
         s(:args, s(:kwoptarg, :foo, s(:int, 1))),
-        s(:nil)),
-      %q{def f(foo: 1); nil; end},
+        nil),
+      %q{def f(foo: 1); end},
       %q{      ~~~ name (args.kwoptarg)
         |      ~~~~~~ expression (args.kwoptarg)},
       ALL_VERSIONS - %w(1.8 1.9))
@@ -1619,8 +1635,8 @@ class TestParser < Minitest::Test
     assert_parses(
       s(:def, :f,
         s(:args, s(:kwrestarg, :foo)),
-        s(:nil)),
-      %q{def f(**foo); nil; end},
+        nil),
+      %q{def f(**foo); end},
       %q{        ~~~ name (args.kwrestarg)
         |      ~~~~~ expression (args.kwrestarg)},
       ALL_VERSIONS - %w(1.8 1.9))
@@ -1630,8 +1646,8 @@ class TestParser < Minitest::Test
     assert_parses(
       s(:def, :f,
         s(:args, s(:kwrestarg)),
-        s(:nil)),
-      %q{def f(**); nil; end},
+        nil),
+      %q{def f(**); end},
       %q{      ~~ expression (args.kwrestarg)},
       ALL_VERSIONS - %w(1.8 1.9))
   end
@@ -1640,16 +1656,16 @@ class TestParser < Minitest::Test
     assert_parses(
       s(:def, :f,
         s(:args, s(:blockarg, :block)),
-        s(:nil)),
-      %q{def f(&block); nil; end},
+        nil),
+      %q{def f(&block); end},
       %q{       ~~~~~ name (args.blockarg)
         |      ~~~~~~ expression (args.blockarg)})
   end
 
   def assert_parses_args(ast, code, versions=ALL_VERSIONS)
     assert_parses(
-      s(:def, :f, ast, s(:nil)),
-      %Q{def f #{code}; nil; end},
+      s(:def, :f, ast, nil),
+      %Q{def f #{code}; end},
       %q{},
       versions)
   end
@@ -3620,6 +3636,15 @@ class TestParser < Minitest::Test
       %q{ ~~~~~~~~~~ location})
   end
 
+  def test_cond_begin
+    assert_parses(
+      s(:if,
+        s(:begin, s(:lvar, :bar)),
+        s(:lvar, :foo),
+        nil),
+      %q{if (bar); foo; end})
+  end
+
   def test_cond_begin_masgn
     assert_parses(
       s(:if,
@@ -3829,21 +3854,21 @@ class TestParser < Minitest::Test
       %q{     ~~~~~ keyword})
   end
 
-  # TODO implement this
-  # def test_while_post
-  #   assert_parses(
-  #     s(:while_post, s(:lvar, :foo), s(:send, nil, :meth)),
-  #     %q{begin meth end while foo},
-  #     %q{               ~~~~~ keyword})
-  # end
+  def test_while_post
+    assert_parses(
+      s(:while_post, s(:lvar, :foo),
+        s(:kwbegin, s(:send, nil, :meth))),
+      %q{begin meth end while foo},
+      %q{               ~~~~~ keyword})
+  end
 
-  # TODO implement this
-  # def test_until_post
-  #   assert_parses(
-  #     s(:until_post, s(:lvar, :foo), s(:send, nil, :meth)),
-  #     %q{begin meth end until foo},
-  #     %q{               ~~~~~ keyword})
-  # end
+  def test_until_post
+    assert_parses(
+      s(:until_post, s(:lvar, :foo),
+        s(:kwbegin, s(:send, nil, :meth))),
+      %q{begin meth end until foo},
+      %q{               ~~~~~ keyword})
+  end
 
   def test_while_masgn
     assert_diagnoses(
@@ -4011,7 +4036,7 @@ class TestParser < Minitest::Test
 
   def test_rescue
     assert_parses(
-      s(:begin,
+      s(:kwbegin,
         s(:rescue, s(:send, nil, :meth),
           s(:resbody, nil, nil, s(:lvar, :foo)),
           nil)),
@@ -4026,7 +4051,7 @@ class TestParser < Minitest::Test
 
   def test_rescue_else
     assert_parses(
-      s(:begin,
+      s(:kwbegin,
         s(:rescue, s(:send, nil, :meth),
           s(:resbody, nil, nil, s(:lvar, :foo)),
           s(:lvar, :bar))),
@@ -4044,7 +4069,7 @@ class TestParser < Minitest::Test
 
   def test_ensure
     assert_parses(
-      s(:begin,
+      s(:kwbegin,
         s(:ensure, s(:send, nil, :meth),
           s(:lvar, :bar))),
       %q{begin; meth; ensure; bar; end},
@@ -4057,7 +4082,7 @@ class TestParser < Minitest::Test
 
   def test_ensure_empty
     assert_parses(
-      s(:begin,
+      s(:kwbegin,
         s(:ensure, nil, nil)),
       %q{begin ensure end},
       %q{~~~~~ begin
@@ -4069,7 +4094,7 @@ class TestParser < Minitest::Test
 
   def test_rescue_ensure
     assert_parses(
-      s(:begin,
+      s(:kwbegin,
         s(:ensure,
           s(:rescue,
             s(:send, nil, :meth),
@@ -4085,7 +4110,7 @@ class TestParser < Minitest::Test
 
   def test_rescue_else_ensure
     assert_parses(
-      s(:begin,
+      s(:kwbegin,
         s(:ensure,
           s(:rescue,
             s(:send, nil, :meth),
@@ -4144,7 +4169,7 @@ class TestParser < Minitest::Test
 
   def test_resbody_list
     assert_parses(
-      s(:begin,
+      s(:kwbegin,
         s(:rescue,
           s(:send, nil, :meth),
           s(:resbody,
@@ -4157,7 +4182,7 @@ class TestParser < Minitest::Test
 
   def test_resbody_list_mrhs
     assert_parses(
-      s(:begin,
+      s(:kwbegin,
         s(:rescue,
           s(:send, nil, :meth),
           s(:resbody,
@@ -4172,7 +4197,7 @@ class TestParser < Minitest::Test
 
   def test_resbody_var
     assert_parses(
-      s(:begin,
+      s(:kwbegin,
         s(:rescue,
           s(:send, nil, :meth),
           s(:resbody, nil, s(:lvasgn, :ex), s(:lvar, :bar)),
@@ -4180,7 +4205,7 @@ class TestParser < Minitest::Test
       %q{begin; meth; rescue => ex; bar; end})
 
     assert_parses(
-      s(:begin,
+      s(:kwbegin,
         s(:rescue,
           s(:send, nil, :meth),
           s(:resbody, nil, s(:ivasgn, :@ex), s(:lvar, :bar)),
@@ -4190,7 +4215,7 @@ class TestParser < Minitest::Test
 
   def test_resbody_list_var
     assert_parses(
-      s(:begin,
+      s(:kwbegin,
         s(:rescue,
           s(:send, nil, :meth),
           s(:resbody,
@@ -4247,6 +4272,14 @@ class TestParser < Minitest::Test
   # Miscellanea
   #
 
+  def test_kwbegin_compstmt
+    assert_parses(
+      s(:kwbegin,
+        s(:send, nil, :foo!),
+        s(:send, nil, :bar!)),
+      %q{begin foo!; bar! end})
+  end
+
   def test_crlf_line_endings
     with_versions(ALL_VERSIONS) do |_ver, parser|
       source_file = Parser::Source::Buffer.new('(comments)')
@@ -4269,7 +4302,7 @@ class TestParser < Minitest::Test
   def test_begin_cmdarg
     assert_parses(
       s(:send, nil, :p,
-        s(:begin,
+        s(:kwbegin,
           s(:block,
             s(:send, s(:int, 1), :times),
             s(:args),
@@ -4391,7 +4424,7 @@ class TestParser < Minitest::Test
     assert_parses(
       s(:block,
         s(:send, nil, :desc,
-          s(:str, "foo")),
+          s(:str, 'foo')),
         s(:args), nil),
       %q{desc "foo" do end})
   end