parser 2.4.0.2 → 2.5.0.0

data/lib/parser/tree_rewriter.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+module Parser
+
+  ##
+  # {Parser::TreeRewriter} offers a basic API that makes it easy to rewrite
+  # existing ASTs. It's built on top of {Parser::AST::Processor} and
+  # {Parser::Source::TreeRewriter}
+  #
+  # For example, assume you want to remove `do` tokens from a while statement.
+  # You can do this as following:
+  #
+  #     require 'parser/current'
+  #
+  #     class RemoveDo < Parser::TreeRewriter
+  #       def on_while(node)
+  #         # Check if the statement starts with "do"
+  #         if node.location.begin.is?('do')
+  #           remove(node.location.begin)
+  #         end
+  #       end
+  #     end
+  #
+  #     code = <<-EOF
+  #     while true do
+  #       puts 'hello'
+  #     end
+  #     EOF
+  #
+  #     buffer        = Parser::Source::Buffer.new('(example)')
+  #     buffer.source = code
+  #     rewriter      = RemoveDo.new
+  #
+  #     # Rewrite the AST, returns a String with the new form.
+  #     puts rewriter.rewrite(buffer)
+  #
+  # This would result in the following Ruby code:
+  #
+  #     while true
+  #       puts 'hello'
+  #     end
+  #
+  # Keep in mind that {Parser::TreeRewriter} does not take care of indentation when
+  # inserting/replacing code so you'll have to do this yourself.
+  #
+  # See also [a blog entry](http://whitequark.org/blog/2013/04/26/lets-play-with-ruby-code/)
+  # describing rewriters in greater detail.
+  #
+  # @api public
+  #
+  class TreeRewriter < Parser::AST::Processor
+    ##
+    # Rewrites the AST/source buffer and returns a String containing the new
+    # version.
+    #
+    # @param [Parser::Source::Buffer] source_buffer
+    # @param [Parser::AST::Node] ast
+    # @param [Symbol] crossing_deletions:, different_replacements:, swallowed_insertions:
+    #                 policy arguments for TreeRewriter (optional)
+    # @return [String]
+    #
+    def rewrite(source_buffer,
+                ast,
+                **policy)
+      @source_rewriter = Parser::Source::TreeRewriter.new(source_buffer, **policy)
+
+      process(ast)
+
+      @source_rewriter.process
+    end
+
+    ##
+    # Returns `true` if the specified node is an assignment node, returns false
+    # otherwise.
+    #
+    # @param [Parser::AST::Node] node
+    # @return [Boolean]
+    #
+    def assignment?(node)
+      [:lvasgn, :ivasgn, :gvasgn, :cvasgn, :casgn].include?(node.type)
+    end
+
+    ##
+    # Removes the source range.
+    #
+    # @param [Parser::Source::Range] range
+    #
+    def remove(range)
+      @source_rewriter.remove(range)
+    end
+
+    ##
+    # Wraps the given source range with the given values.
+    #
+    # @param [Parser::Source::Range] range
+    # @param [String] content
+    #
+    def wrap(range, before, after)
+      @source_rewriter.wrap(range, before, after)
+    end
+
+    ##
+    # Inserts new code before the given source range.
+    #
+    # @param [Parser::Source::Range] range
+    # @param [String] content
+    #
+    def insert_before(range, content)
+      @source_rewriter.insert_before(range, content)
+    end
+
+    ##
+    # Inserts new code after the given source range.
+    #
+    # @param [Parser::Source::Range] range
+    # @param [String] content
+    #
+    def insert_after(range, content)
+      @source_rewriter.insert_after(range, content)
+    end
+
+    ##
+    # Replaces the code of the source range `range` with `content`.
+    #
+    # @param [Parser::Source::Range] range
+    # @param [String] content
+    #
+    def replace(range, content)
+      @source_rewriter.replace(range, content)
+    end
+  end
+
+end

data/lib/parser/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Parser
-  VERSION = '2.4.0.2'
+  VERSION = '2.5.0.0'
 end

data/parser.gemspec

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 require File.expand_path('../lib/parser/version', __FILE__)
 
@@ -30,7 +31,9 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^test/})
   spec.require_paths = ['lib']
 
-  spec.add_dependency             'ast',       '~> 2.3'
+  spec.required_ruby_version = '>= 2.0.0'
+
+  spec.add_dependency             'ast',       '~> 2.4.0'
 
   spec.add_development_dependency 'bundler',   '~> 1.16'
   spec.add_development_dependency 'rake',      '~> 10.0'

data/test/bug_163/fixtures/input.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 if(true)
   puts "Hello, world!"
 end

data/test/bug_163/fixtures/output.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 if true
   puts "Hello, world!"
 end

data/test/bug_163/rewriter.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Rewriter < Parser::Rewriter
   def on_if(node)
     # Crude, totally-not-usable-in-the-real-world code to remove optional

data/test/helper.rb

@@ -1,18 +1,18 @@
+# frozen_string_literal: true
+
 require 'tempfile'
 require 'minitest/test'
 
 require 'simplecov'
 
 if ENV.include?('COVERAGE') && SimpleCov.usable?
-  if defined?(TracePoint)
-    require_relative 'racc_coverage_helper'
+  require_relative 'racc_coverage_helper'
 
-    RaccCoverage.start(%w(ruby18.y ruby19.y ruby20.y ruby21.y ruby22.y ruby23.y ruby24.y ruby25.y),
-                       File.expand_path('../../lib/parser', __FILE__))
+  RaccCoverage.start(%w(ruby18.y ruby19.y ruby20.y ruby21.y ruby22.y ruby23.y ruby24.y ruby25.y),
+                     File.expand_path('../../lib/parser', __FILE__))
 
-    # Report results faster.
-    at_exit { RaccCoverage.stop }
-  end
+  # Report results faster.
+  at_exit { RaccCoverage.stop }
 
   SimpleCov.start do
     self.formatter = SimpleCov::Formatter::MultiFormatter[

data/test/parse_helper.rb

@@ -1,17 +1,13 @@
+# frozen_string_literal: true
+
 module ParseHelper
   include AST::Sexp
 
-  if RUBY_VERSION == '1.8.7'
-    require 'parser/ruby18'
-
-    ALL_VERSIONS = %w(1.8)
-  else
-    require 'parser/all'
-    require 'parser/macruby'
-    require 'parser/rubymotion'
+  require 'parser/all'
+  require 'parser/macruby'
+  require 'parser/rubymotion'
 
-    ALL_VERSIONS = %w(1.8 1.9 2.0 2.1 2.2 2.3 2.4 2.5 mac ios)
-  end
+  ALL_VERSIONS = %w(1.8 1.9 2.0 2.1 2.2 2.3 2.4 2.5 mac ios)
 
   def setup
     @diagnostics = []
@@ -185,6 +181,42 @@ module ParseHelper
     end
   end
 
+  # Use like this:
+  # ~~~
+  # assert_diagnoses_many(
+  #   [
+  #     [:warning, :ambiguous_literal],
+  #     [:error, :unexpected_token, { :token => :tLCURLY }]
+  #   ],
+  #   %q{m /foo/ {}},
+  #   SINCE_2_4)
+  # ~~~
+  def assert_diagnoses_many(diagnostics, code, versions=ALL_VERSIONS)
+    with_versions(versions) do |version, parser|
+      source_file = Parser::Source::Buffer.new('(assert_diagnoses_many)')
+      source_file.source = code
+
+      begin
+        parser = parser.parse(source_file)
+      rescue Parser::SyntaxError
+        # do nothing; the diagnostic was reported
+      end
+
+      assert_equal diagnostics.count, @diagnostics.count
+
+      diagnostics.zip(@diagnostics) do |expected_diagnostic, actual_diagnostic|
+        level, reason, arguments = expected_diagnostic
+        arguments ||= {}
+        message     = Parser::MESSAGES[reason] % arguments
+
+        assert_equal level, actual_diagnostic.level
+        assert_equal reason, actual_diagnostic.reason
+        assert_equal arguments, actual_diagnostic.arguments
+        assert_equal message, actual_diagnostic.message
+      end
+    end
+  end
+
   def refute_diagnoses(code, versions=ALL_VERSIONS)
     with_versions(versions) do |version, parser|
       source_file = Parser::Source::Buffer.new('(refute_diagnoses)')
@@ -202,6 +234,21 @@ module ParseHelper
     end
   end
 
+  def assert_context(context, code, versions=ALL_VERSIONS)
+    with_versions(versions) do |version, parser|
+      source_file = Parser::Source::Buffer.new('(assert_context)')
+      source_file.source = code
+
+      begin
+        parser.parse(source_file)
+      rescue Parser::SyntaxError
+        # do nothing; the diagnostic was reported
+      end
+
+      assert_equal parser.context.stack, context, "(#{version}) parsing context"
+    end
+  end
+
   SOURCE_MAP_DESCRIPTION_RE =
       /(?x)
        ^(?# $1 skip)            ^(\s*)

data/test/racc_coverage_helper.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'racc/grammarfileparser'
 
 # Unfortunately, Ruby's Coverage module ignores module_eval statements,

data/test/test_base.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'helper'
 require 'parser/current'
 

data/test/test_current.rb

@@ -1,13 +1,11 @@
+# frozen_string_literal: true
+
 require 'helper'
 require 'parser/current'
 
 class TestCurrent < Minitest::Test
   def test_current
     case RUBY_VERSION
-    when '1.8.7'
-      assert_equal Parser::Ruby18, Parser::CurrentRuby
-    when '1.9.2', '1.9.3'
-      assert_equal Parser::Ruby19, Parser::CurrentRuby
     when '2.0.0'
       assert_equal Parser::Ruby20, Parser::CurrentRuby
     when /^2\.1\.\d+/

data/test/test_diagnostic.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'helper'
 
 class TestDiagnostic < Minitest::Test
@@ -18,7 +20,7 @@ class TestDiagnostic < Minitest::Test
   end
 
   def test_freezes
-    string     = 'foo'
+    string     = 'foo'.dup
     highlights = [@range2]
 
     diag = Parser::Diagnostic.new(:error, :escape_eof, @range1, highlights)

data/test/test_diagnostic_engine.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'helper'
 
 class TestDiagnosticEngine < Minitest::Test

data/test/test_encoding.rb

@@ -1,4 +1,5 @@
 # encoding: binary
+# frozen_string_literal: true
 
 require 'helper'
 
@@ -9,70 +10,81 @@ class TestEncoding < Minitest::Test
     Parser::Source::Buffer.recognize_encoding(string)
   end
 
-  if defined?(Encoding)
-    require 'parser/all'
+  require 'parser/all'
 
-    def test_default
-      assert_nil recognize('foobar')
-    end
+  def test_default
+    assert_nil recognize('foobar')
+  end
 
-    def test_bom
-      assert_equal Encoding::UTF_8, recognize("\xef\xbb\xbf\nfoobar")
-      assert_equal Encoding::UTF_8, recognize("\xef\xbb\xbf# coding:koi8-r\nfoobar")
-    end
+  def test_bom
+    assert_equal Encoding::UTF_8, recognize("\xef\xbb\xbf\nfoobar")
+    assert_equal Encoding::UTF_8, recognize("\xef\xbb\xbf# coding:koi8-r\nfoobar")
+  end
 
-    def test_magic_comment
-      assert_equal Encoding::KOI8_R, recognize("# coding:koi8-r\nfoobar")
-    end
+  def test_magic_comment
+    assert_equal Encoding::KOI8_R, recognize("# coding:koi8-r\nfoobar")
+  end
 
-    def test_shebang
-      assert_equal Encoding::KOI8_R, recognize("#!/bin/foo\n# coding:koi8-r\nfoobar")
-    end
+  def test_shebang
+    assert_equal Encoding::KOI8_R, recognize("#!/bin/foo\n# coding:koi8-r\nfoobar")
+  end
 
-    def test_case
-      assert_equal Encoding::KOI8_R, recognize("# coding:KoI8-r\nfoobar")
-    end
+  def test_case
+    assert_equal Encoding::KOI8_R, recognize("# coding:KoI8-r\nfoobar")
+  end
 
-    def test_space
-      assert_equal Encoding::KOI8_R, recognize("# coding : koi8-r\nfoobar")
-    end
+  def test_space
+    assert_equal Encoding::KOI8_R, recognize("# coding : koi8-r\nfoobar")
+  end
 
-    def test_empty
-      assert_nil recognize('')
-    end
+  def test_empty
+    assert_nil recognize('')
+  end
 
-    def test_no_comment
-      assert_nil recognize(%{require 'cane/encoding_aware_iterator'})
-    end
+  def test_no_comment
+    assert_nil recognize(%{require 'cane/encoding_aware_iterator'})
+  end
 
-    def test_adjacent
-      assert_nil recognize('# codingkoi8-r')
-      assert_nil recognize('# coding koi8-r')
-    end
+  def test_adjacent
+    assert_nil recognize('# codingkoi8-r')
+    assert_nil recognize('# coding koi8-r')
+  end
 
-    def test_utf8_mac
-      assert_equal Encoding::UTF8_MAC, recognize('# coding: utf8-mac')
-    end
+  def test_utf8_mac
+    assert_equal Encoding::UTF8_MAC, recognize('# coding: utf8-mac')
+  end
 
-    def test_suffix
-      assert_equal Encoding::UTF_8, recognize('# coding: utf-8-dos')
-      assert_equal Encoding::UTF_8, recognize('# coding: utf-8-unix')
-      assert_equal Encoding::UTF_8, recognize('# coding: utf-8-mac')
+  def test_suffix
+    assert_equal Encoding::UTF_8, recognize('# coding: utf-8-dos')
+    assert_equal Encoding::UTF_8, recognize('# coding: utf-8-unix')
+    assert_equal Encoding::UTF_8, recognize('# coding: utf-8-mac')
 
-      assert_raises(ArgumentError) do
-        assert_nil recognize('# coding: utf-8-dicks')
-      end
+    assert_raises(ArgumentError) do
+      assert_nil recognize('# coding: utf-8-dicks')
     end
+  end
 
-    def test_parse_18_invalid_enc
-      ast = Parser::Ruby18.parse("# encoding:feynman-diagram\n1")
-      assert_equal ast, s(:int, 1)
-    end
+  def test_parse_18_invalid_enc
+    ast = Parser::Ruby18.parse("# encoding:feynman-diagram\n1")
+    assert_equal ast, s(:int, 1)
+  end
 
-    def test_parse_19_invalid_enc
-      assert_raises(ArgumentError) do
-        Parser::Ruby19.parse("# encoding:feynman-diagram\n1")
-      end
+  def test_parse_19_invalid_enc
+    assert_raises(ArgumentError) do
+      Parser::Ruby19.parse("# encoding:feynman-diagram\n1")
     end
   end
+
+  def test_ending_comment
+    assert_nil recognize('foo # coding: koi8-r')
+  end
+
+  def test_wrong_prefix
+    assert_nil recognize('# decoding: koi8-r')
+  end
+
+  def test_no_spaces
+    assert_equal Encoding::KOI8_R, recognize('#encoding:koi8-r')
+    assert_equal Encoding::KOI8_R, recognize('#coding:koi8-r')
+  end
 end