parser 2.4.0.2 → 2.5.0.0

data/test/test_runner_rewrite.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require 'pathname'
+require 'fileutils'
+require 'shellwords'
+require 'open3'
+
+BASE_DIR = Pathname.new(__FILE__) + '..'
+require (BASE_DIR + 'helper').expand_path
+
+class TestRunnerRewrite < Minitest::Test
+  def assert_rewriter_output(path, args, input: 'input.rb', output: 'output.rb', expected_output: '', expected_error: '')
+    @ruby_rewrite = BASE_DIR.expand_path + '../bin/ruby-rewrite'
+    @test_dir     = BASE_DIR + path
+    @fixtures_dir = @test_dir + 'fixtures'
+
+    Dir.mktmpdir("parser", BASE_DIR.expand_path.to_s) do |tmp_dir|
+      tmp_dir = Pathname.new(tmp_dir)
+      sample_file = tmp_dir + "#{path}.rb"
+      sample_file_expanded = sample_file.expand_path
+      expected_file = @fixtures_dir + output
+
+      FileUtils.cp(@fixtures_dir + input, sample_file_expanded)
+      stdout, stderr, exit_code = Dir.chdir @test_dir do
+        Open3.capture3 %Q{
+          #{Shellwords.escape(@ruby_rewrite.to_s)} #{args} \
+          #{Shellwords.escape(sample_file_expanded.to_s)}
+        }
+      end
+
+      assert_equal expected_output.chomp, stdout.chomp
+      assert_match expected_error.chomp, stderr.chomp
+      assert_equal File.read(expected_file.expand_path), File.read(sample_file)
+    end
+  end
+
+  def test_rewriter_bug_163
+    assert_rewriter_output('bug_163',
+      '--modify  -l rewriter.rb',
+      expected_error: Parser::Rewriter::DEPRECATION_WARNING
+    )
+  end
+
+  def test_tree_rewriter
+    assert_rewriter_output('using_tree_rewriter', '-l using_tree_rewriter.rb --modify')
+  end
+end

data/test/test_source_buffer.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'helper'
 
 class TestSourceBuffer < Minitest::Test
@@ -29,17 +31,15 @@ class TestSourceBuffer < Minitest::Test
     end
   end
 
-  if defined?(Encoding)
-    def test_source_setter_encoding_error
-      error = assert_raises EncodingError do
-        @buffer.source = [
-          '# encoding: utf-8',
-          "# \xf9"
-        ].join("\n")
-      end
-
-      assert_match /invalid byte sequence in UTF\-8/, error.message
+  def test_source_setter_encoding_error
+    error = assert_raises EncodingError do
+      @buffer.source = [
+        '# encoding: utf-8',
+        "# \xf9"
+      ].join("\n")
     end
+
+    assert_match /invalid byte sequence in UTF\-8/, error.message
   end
 
   def test_read
@@ -117,6 +117,18 @@ class TestSourceBuffer < Minitest::Test
     end
   end
 
+  def test_source_range
+    @buffer = Parser::Source::Buffer.new('(string)', 5)
+
+    assert_raises RuntimeError do
+      @buffer.source_range
+    end
+
+    @buffer.source = "abc\ndef\nghi\n"
+
+    assert_equal Parser::Source::Range.new(@buffer, 0, @buffer.source.size), @buffer.source_range
+  end
+
   def test_last_line
     @buffer.source = "1\nfoo\nbar"
     assert_equal 3, @buffer.last_line

data/test/test_source_comment.rb

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

data/test/test_source_comment_associator.rb

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

data/test/test_source_map.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'helper'
 require 'parse_helper'
 

data/test/test_source_range.rb

@@ -1,21 +1,28 @@
+# frozen_string_literal: true
+
 require 'helper'
 
 class TestSourceRange < Minitest::Test
   def setup
     @buf = Parser::Source::Buffer.new('(string)')
     @buf.source = "foobar\nbaz"
+    @sr1_3 = Parser::Source::Range.new(@buf, 1, 3)
+    @sr2_2 = Parser::Source::Range.new(@buf, 2, 2)
+    @sr3_3 = Parser::Source::Range.new(@buf, 3, 3)
+    @sr2_6 = Parser::Source::Range.new(@buf, 2, 6)
+    @sr5_8 = Parser::Source::Range.new(@buf, 5, 8)
+    @sr5_7 = Parser::Source::Range.new(@buf, 5, 7)
+    @sr6_7 = Parser::Source::Range.new(@buf, 6, 7)
   end
 
   def test_initialize
-    sr = Parser::Source::Range.new(@buf, 1, 2)
-    assert_equal 1, sr.begin_pos
-    assert_equal 2, sr.end_pos
-    assert sr.frozen?
+    assert_equal 1, @sr1_3.begin_pos
+    assert_equal 3, @sr1_3.end_pos
+    assert @sr1_3.frozen?
   end
 
   def test_size
-    sr = Parser::Source::Range.new(@buf, 1, 3)
-    assert_equal 2, sr.size
+    assert_equal 4, @sr2_6.size
   end
 
   def test_bad_size
@@ -25,54 +32,86 @@ class TestSourceRange < Minitest::Test
   end
 
   def test_join
-    sr1 = Parser::Source::Range.new(@buf, 1, 2)
-    sr2 = Parser::Source::Range.new(@buf, 5, 8)
-    sr = sr1.join(sr2)
+    sr = @sr1_3.join(@sr5_8)
 
     assert_equal 1, sr.begin_pos
     assert_equal 8, sr.end_pos
   end
 
   def test_intersect
-    sr1 = Parser::Source::Range.new(@buf, 1, 3)
-    sr2 = Parser::Source::Range.new(@buf, 2, 6)
-    sr3 = Parser::Source::Range.new(@buf, 5, 8)
+    assert_equal 2, @sr1_3.intersect(@sr2_6).begin_pos
+    assert_equal 3, @sr1_3.intersect(@sr2_6).end_pos
+    assert_equal 5, @sr2_6.intersect(@sr5_8).begin_pos
+    assert_equal 6, @sr2_6.intersect(@sr5_8).end_pos
+    assert @sr1_3.intersect(@sr5_8) == nil
+    assert_equal 2, @sr1_3.intersect(@sr2_2).begin_pos
+    assert_equal 2, @sr1_3.intersect(@sr2_2).end_pos
+    assert_equal 2, @sr2_2.intersect(@sr2_2).begin_pos
+    assert_equal 2, @sr2_2.intersect(@sr2_2).end_pos
+  end
 
-    assert_equal 2, sr1.intersect(sr2).begin_pos
-    assert_equal 3, sr1.intersect(sr2).end_pos
-    assert_equal 5, sr2.intersect(sr3).begin_pos
-    assert_equal 6, sr2.intersect(sr3).end_pos
-    assert sr1.intersect(sr3) == nil
+  def test_overlaps
+    assert !@sr1_3.overlaps?(@sr5_8)
+    assert @sr1_3.overlaps?(@sr2_6)
+    assert @sr2_6.overlaps?(@sr5_8)
+    assert @sr1_3.overlaps?(@sr2_2)
+    assert !@sr2_6.overlaps?(@sr2_2)
+    assert @sr2_2.overlaps?(@sr2_2)
+  end
+
+  def check_relationship(relationship, sr1, sr2, reflexive_relationship = relationship)
+    # Double check equality
+    assert_equal true, sr1 == sr1.dup
+    assert_equal true, sr1 != sr2
+    # Check relationships and reflexivity
+    assert_equal true, sr1.send(relationship, sr2)
+    assert_equal true, sr2.send(reflexive_relationship, sr1)
+    # Check it's not true for itself
+    assert_equal false, sr1.send(relationship, sr1)
+    # Check other relationships return false
+    others = %i[disjoint? crossing? contains? contained?] - [relationship, reflexive_relationship]
+    others.each do |other_rel|
+      assert_equal false, sr1.send(other_rel, sr2), other_rel
+      assert_equal false, sr2.send(other_rel, sr1), other_rel
+    end
   end
 
   def test_disjoint
-    sr1 = Parser::Source::Range.new(@buf, 1, 3)
-    sr2 = Parser::Source::Range.new(@buf, 2, 6)
-    sr3 = Parser::Source::Range.new(@buf, 5, 8)
+    check_relationship(:disjoint?, @sr1_3, @sr5_8)
+    check_relationship(:disjoint?, @sr2_2, @sr2_6)
+    check_relationship(:disjoint?, @sr2_2, @sr3_3)
+    check_relationship(:disjoint?, @sr2_6, @sr6_7)
+  end
 
-    assert sr1.disjoint?(sr3)
-    assert !sr1.disjoint?(sr2)
-    assert !sr2.disjoint?(sr3)
+  def test_crossing
+    check_relationship(:crossing?, @sr1_3, @sr2_6)
   end
 
-  def test_overlaps
-    sr1 = Parser::Source::Range.new(@buf, 1, 3)
-    sr2 = Parser::Source::Range.new(@buf, 2, 6)
-    sr3 = Parser::Source::Range.new(@buf, 5, 8)
+  def test_containment
+    check_relationship(:contained?, @sr2_2, @sr1_3, :contains?)
+    check_relationship(:contained?, @sr5_7, @sr5_8, :contains?)
+    check_relationship(:contained?, @sr6_7, @sr5_8, :contains?)
+  end
 
-    assert !sr1.overlaps?(sr3)
-    assert sr1.overlaps?(sr2)
-    assert sr2.overlaps?(sr3)
+  def test_order
+    assert_equal  0, @sr1_3 <=> @sr1_3
+    assert_equal -1, @sr1_3 <=> @sr5_8
+    assert_equal -1, @sr2_2 <=> @sr2_6
+    assert_equal +1, @sr2_6 <=> @sr2_2
+
+    assert_equal -1, @sr1_3 <=> @sr2_6
+
+    assert_equal +1, @sr2_2 <=> @sr1_3
+    assert_equal -1, @sr1_3 <=> @sr2_2
+    assert_equal -1, @sr5_7 <=> @sr5_8
+
+    assert_nil @sr1_3 <=> Parser::Source::Range.new(@buf.dup, 1, 3)
+    assert_nil @sr1_3 <=> 4
   end
 
   def test_empty
-    sr1 = Parser::Source::Range.new(@buf, 1, 3)
-    sr2 = Parser::Source::Range.new(@buf, 2, 2)
-    sr3 = Parser::Source::Range.new(@buf, 7, 8)
-
-    assert !sr1.empty?
-    assert sr2.empty?
-    assert !sr3.empty?
+    assert !@sr1_3.empty?
+    assert @sr2_2.empty?
   end
 
   def test_line
@@ -93,15 +132,13 @@ class TestSourceRange < Minitest::Test
   end
 
   def test_begin_end
-    sr = Parser::Source::Range.new(@buf, 1, 5)
+    sr_beg = @sr2_6.begin
+    assert_equal 2, sr_beg.begin_pos
+    assert_equal 2, sr_beg.end_pos
 
-    sr_beg = sr.begin
-    assert_equal 1, sr_beg.begin_pos
-    assert_equal 1, sr_beg.end_pos
-
-    sr_end = sr.end
-    assert_equal 5, sr_end.begin_pos
-    assert_equal 5, sr_end.end_pos
+    sr_end = @sr2_6.end
+    assert_equal 6, sr_end.begin_pos
+    assert_equal 6, sr_end.end_pos
   end
 
   def test_source
@@ -122,4 +159,14 @@ class TestSourceRange < Minitest::Test
     sr = Parser::Source::Range.new(@buf, 8, 9)
     assert_equal '(string):2:2', sr.to_s
   end
+
+  def test_with
+    sr2 = @sr1_3.with(begin_pos: 2)
+    sr3 = @sr1_3.with(end_pos: 4)
+
+    assert_equal 2, sr2.begin_pos
+    assert_equal 3, sr2.end_pos
+    assert_equal 1, sr3.begin_pos
+    assert_equal 4, sr3.end_pos
+  end
 end

data/test/test_source_rewriter.rb

@@ -1,10 +1,12 @@
+# frozen_string_literal: true
+
 require 'helper'
 
 class TestSourceRewriter < Minitest::Test
   def setup
     @buf = Parser::Source::Buffer.new('(rewriter)')
     @buf.source = 'foo bar baz'
-
+    Parser::Source::Rewriter.warned_of_deprecation = true
     @rewriter = Parser::Source::Rewriter.new(@buf)
   end
 

data/test/test_source_rewriter_action.rb

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

data/test/test_source_tree_rewriter.rb

@@ -0,0 +1,177 @@
+# frozen_string_literal: true
+
+require 'helper'
+
+class TestSourceTreeRewriter < Minitest::Test
+  def setup
+    @buf = Parser::Source::Buffer.new('(rewriter)')
+    @buf.source = 'puts(:hello, :world)'
+
+    @hello = range(5, 6)
+    @comma_space = range(11,2)
+    @world = range(13,6)
+  end
+
+  def range(from, len)
+    Parser::Source::Range.new(@buf, from, from + len)
+  end
+
+  # Returns either:
+  #  - String (Normal operation)
+  #  - [diagnostic, ...] (Diagnostics)
+  #  - Parser::ClobberingError
+  #
+  def apply(actions, **policy)
+    diagnostics = []
+    diags = -> { diagnostics.flatten.map(&:strip).join("\n") }
+    rewriter = Parser::Source::TreeRewriter.new(@buf, **policy)
+    rewriter.diagnostics.consumer = -> diag { diagnostics << diag.render }
+    actions.each do |action, range, *args|
+      rewriter.public_send(action, range, *args)
+    end
+    if diagnostics.empty?
+      rewriter.process
+    else
+      diags.call
+    end
+  rescue ::Parser::ClobberingError => e
+    [::Parser::ClobberingError, diags.call]
+  end
+
+  # Expects ordered actions to be grouped together
+  def check_actions(expected, grouped_actions, **policy)
+    grouped_actions.permutation do |sequence|
+      # [action, [action, action]]  => [action, action, action]
+      # except we can't use flatten because "action" are arrays themselves
+      actions = sequence.flat_map { |group| group.first.is_a?(Array) ? group : [group] }
+      assert_equal(expected, apply(actions, **policy))
+    end
+  end
+
+  def assert_actions_result(expected, *actions, **rest)
+    if expected == :raise
+      diagnostic = rest.values.first
+      check_actions([::Parser::ClobberingError, diagnostic], actions)
+    elsif rest.empty?
+      check_actions(expected, actions)
+    else
+      policy, diagnostic = rest.first
+      check_actions(expected, actions, policy => :accept)
+      check_actions(diagnostic, actions, policy => :warn)
+      diagnostic.gsub!(/warning: /, 'error: ')
+      check_actions([::Parser::ClobberingError, diagnostic], actions, policy => :raise)
+    end
+  end
+
+  ### Simple cases
+
+  def test_remove
+    assert_actions_result 'puts(, :world)', [:remove, @hello]
+  end
+
+  def test_insert_before
+    assert_actions_result 'puts(:hello, 42, :world)', [:insert_before, @world, '42, ']
+  end
+
+  def test_insert_after
+    assert_actions_result 'puts(:hello, 42, :world)', [:insert_after, @hello, ', 42']
+  end
+
+  def test_wrap
+    assert_actions_result 'puts([:hello], :world)', [:wrap, @hello, '[', ']']
+  end
+
+  def test_replace
+    assert_actions_result 'puts(:hi, :world)', [:replace, @hello, ':hi']
+  end
+
+  #
+  # All other cases, as per doc
+  #
+
+  def test_crossing_non_deletions
+    check = [
+      [:wrap, '(', ')'],
+      [:remove],
+      [:replace, 'xx'],
+    ]
+    check.combination(2) do |(action, *args), (action_b, *args_b)|
+      next if action == :remove && action_b == :remove
+      assert_actions_result :raise,
+                            [[action, @hello.join(@comma_space), *args],
+                             [action_b, @world.join(@comma_space), *args_b]],
+                            diagnostic: <<-DIAGNOSTIC.chomp
+(rewriter):1:12: error: the rewriting action on:
+(rewriter):1: puts(:hello, :world)
+(rewriter):1:            ^~~~~~~~
+(rewriter):1:6: error: is crossing that on:
+(rewriter):1: puts(:hello, :world)
+(rewriter):1:      ^~~~~~~~
+DIAGNOSTIC
+    end
+  end
+
+
+  def test_crossing_deletions
+    assert_actions_result 'puts()',
+                          [[:remove, @hello.join(@comma_space)],
+                           [:remove, @world.join(@comma_space)]],
+                          crossing_deletions: <<-DIAGNOSTIC.chomp
+(rewriter):1:12: warning: the deletion of:
+(rewriter):1: puts(:hello, :world)
+(rewriter):1:            ^~~~~~~~
+(rewriter):1:6: warning: is crossing:
+(rewriter):1: puts(:hello, :world)
+(rewriter):1:      ^~~~~~~~
+DIAGNOSTIC
+  end
+
+  def test_multiple_actions
+    assert_actions_result 'puts({:hello => [:everybody]})',
+                          [:replace, @comma_space, ' => '],
+                          [:wrap, @hello.join(@world), '{', '}'],
+                          [:replace, @world, ':everybody'],
+                          [:wrap, @world, '[', ']']
+  end
+
+
+  def test_multiple_actions
+    assert_actions_result 'puts({:hello => [:everybody]})',
+                          [:replace, @comma_space, ' => '],
+                          [:wrap, @hello.join(@world), '{', '}'],
+                          [:replace, @world, ':everybody'],
+                          [:wrap, @world, '[', ']']
+  end
+
+  def test_wraps_same_range
+    assert_actions_result 'puts([(:hello)], :world)',
+                           [[:wrap, @hello, '(', ')'],
+                            [:wrap, @hello, '[', ']']]
+  end
+
+  def test_replace_same_range
+    assert_actions_result 'puts(:hey, :world)',
+                           [[:replace, @hello, ':hi'],
+                            [:replace, @hello, ':hey']],
+                           different_replacements: <<-DIAGNOSTIC.chomp
+(rewriter):1:6: warning: different replacements: :hey vs :hi
+(rewriter):1: puts(:hello, :world)
+(rewriter):1:      ^~~~~~
+DIAGNOSTIC
+  end
+
+  def test_swallowed_insertions
+    assert_actions_result 'puts(:hi)',
+                           [[:wrap, @hello.adjust(begin_pos: 1), '__', '__'],
+                            [:replace, @world.adjust(end_pos: -2), 'xx'],
+                            [:replace, @hello.join(@world), ':hi']],
+                           swallowed_insertions: <<-DIAGNOSTIC.chomp
+(rewriter):1:6: warning: this replacement:
+(rewriter):1: puts(:hello, :world)
+(rewriter):1:      ^~~~~~~~~~~~~~
+(rewriter):1:7: warning: swallows some inner rewriting actions:
+(rewriter):1: puts(:hello, :world)
+(rewriter):1:       ^~~~~  ~~~~
+DIAGNOSTIC
+  end
+end