parser 2.7.0.5 → 2.7.1.4

data/test/test_runner_parse.rb

@@ -7,7 +7,7 @@ class TestRunnerParse < Minitest::Test
   PATH_TO_RUBY_PARSE = File.expand_path('../bin/ruby-parse', __dir__).freeze
 
   def assert_prints(argv, expected_output)
-    stdout, stderr, status = Open3.capture3(PATH_TO_RUBY_PARSE, *argv)
+    stdout, _stderr, status = Open3.capture3(PATH_TO_RUBY_PARSE, *argv)
 
     assert_equal 0, status.to_i
     assert_includes(stdout, expected_output)
@@ -18,6 +18,27 @@ class TestRunnerParse < Minitest::Test
                   's(:int, 123)'
   end
 
+  def test_emit_modern_ruby
+    assert_prints ['-e', '->{}'],
+                  '(lambda)'
+    assert_prints ['-e', 'self[1] = 2'],
+                  'indexasgn'
+  end
+
+  def test_emit_legacy
+    assert_prints ['--legacy', '-e', '->{}'],
+                  '(send nil :lambda)'
+    assert_prints ['--legacy', '-e', 'self[1] = 2'],
+                  ':[]='
+  end
+
+  def test_emit_legacy_lambda
+    assert_prints ['--legacy-lambda', '-e', '->{}'],
+                  '(send nil :lambda)'
+    assert_prints ['--legacy-lambda', '-e', 'self[1] = 2'],
+                  'indexasgn'
+  end
+
   def test_emit_json
     assert_prints ['--emit-json', '-e', '123'],
                   '["int",123]'

data/test/test_runner_rewrite.rb

@@ -21,7 +21,7 @@ class TestRunnerRewrite < Minitest::Test
       expected_file = @fixtures_dir + output
 
       FileUtils.cp(@fixtures_dir + input, sample_file_expanded)
-      stdout, stderr, exit_code = Dir.chdir @test_dir do
+      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)}

data/test/test_source_buffer.rb

@@ -20,6 +20,9 @@ class TestSourceBuffer < Minitest::Test
 
     buffer = Parser::Source::Buffer.new('(string)', 5)
     assert_equal 5, buffer.first_line
+
+    buffer = Parser::Source::Buffer.new('(string)', source: '2+2')
+    assert_equal '2+2', buffer.source
   end
 
   def test_source_setter
@@ -45,7 +48,7 @@ class TestSourceBuffer < Minitest::Test
       ].join("\n")
     end
 
-    assert_match /invalid byte sequence in UTF\-8/, error.message
+    assert_match(/invalid byte sequence in UTF\-8/, error.message)
   end
 
   def test_read

data/test/test_source_comment.rb

@@ -4,8 +4,8 @@ require 'helper'
 
 class TestSourceComment < Minitest::Test
   def setup
-    @buf = Parser::Source::Buffer.new('(string)')
-    @buf.source = "# foo\n=begin foo\nbar\n=end baz\n"
+    @buf = Parser::Source::Buffer.new('(string)',
+      source: "# foo\n=begin foo\nbar\n=end baz\n")
   end
 
   def range(s, e)

data/test/test_source_comment_associator.rb

@@ -95,7 +95,7 @@ class Foo
 end
     END
 
-    klass_node         = ast
+    _klass_node        = ast
     method_node        = ast.children[2]
     body               = method_node.children[2]
     f1_1_node          = body.children[0]
@@ -175,7 +175,7 @@ class Foo
 end
     END
 
-    klass_node         = ast
+    _klass_node        = ast
     method_node        = ast.children[2]
     body               = method_node.children[2]
     f1_1_node          = body.children[0]
@@ -201,12 +201,12 @@ end
   end
 
   def test_associate_empty_tree
-    ast, associations = associate("")
+    _ast, associations = associate("")
     assert_equal 0, associations.size
   end
 
   def test_associate_shebang_only
-    ast, associations = associate(<<-END)
+    _ast, associations = associate(<<-END)
 #!ruby
 class Foo
 end
@@ -216,7 +216,7 @@ end
   end
 
   def test_associate_frozen_string_literal
-    ast, associations = associate(<<-END)
+    _ast, associations = associate(<<-END)
 # frozen_string_literal: true
 class Foo
 end
@@ -226,7 +226,7 @@ end
   end
 
   def test_associate_frozen_string_literal_dash_star_dash
-    ast, associations = associate(<<-END)
+    _ast, associations = associate(<<-END)
 # -*- frozen_string_literal: true -*-
 class Foo
 end
@@ -236,7 +236,7 @@ end
   end
 
   def test_associate_frozen_string_literal_no_space_after_colon
-    ast, associations = associate(<<-END)
+    _ast, associations = associate(<<-END)
 # frozen_string_literal:true
 class Foo
 end
@@ -246,7 +246,7 @@ end
   end
 
   def test_associate_warn_indent
-    ast, associations = associate(<<-END)
+    _ast, associations = associate(<<-END)
 # warn_indent: true
 class Foo
 end
@@ -256,7 +256,7 @@ end
   end
 
   def test_associate_warn_indent_dash_star_dash
-    ast, associations = associate(<<-END)
+    _ast, associations = associate(<<-END)
 # -*- warn_indent: true -*-
 class Foo
 end
@@ -266,7 +266,7 @@ end
   end
 
   def test_associate_warn_past_scope
-    ast, associations = associate(<<-END)
+    _ast, associations = associate(<<-END)
 # warn_past_scope: true
 class Foo
 end
@@ -276,7 +276,7 @@ end
   end
 
   def test_associate_warn_past_scope_dash_star_dash
-    ast, associations = associate(<<-END)
+    _ast, associations = associate(<<-END)
 # -*- warn_past_scope: true -*-
 class Foo
 end
@@ -286,7 +286,7 @@ end
   end
 
   def test_associate_multiple
-    ast, associations = associate(<<-END)
+    _ast, associations = associate(<<-END)
 # frozen_string_literal: true; warn_indent: true
 class Foo
 end
@@ -296,7 +296,7 @@ end
   end
 
   def test_associate_multiple_dash_star_dash
-    ast, associations = associate(<<-END)
+    _ast, associations = associate(<<-END)
 # -*- frozen_string_literal: true; warn_indent: true -*-
 class Foo
 end
@@ -306,7 +306,7 @@ end
   end
 
   def test_associate_no_comments
-    ast, associations = associate(<<-END)
+    _ast, associations = associate(<<-END)
 class Foo
 end
     END
@@ -315,7 +315,7 @@ end
   end
 
   def test_associate_comments_after_root_node
-    ast, associations = associate(<<-END)
+    _ast, associations = associate(<<-END)
 class Foo
 end
 # not associated
@@ -364,4 +364,36 @@ x
     assert_equal ['# bar'],
                  associations[send_node].map(&:text)
   end
+
+  def test_associate_conditional_parent_class
+    ast, associations = associate(<<-END)
+class Foo
+  # bar
+  class Bar
+  end
+end if some_condition
+    END
+
+    if_node = ast
+    _condition, foo_class = if_node.children
+    _foo, _sub_class, bar_class = foo_class.children
+
+    assert_equal 1, associations.size
+    assert_equal ['# bar'],
+                 associations[bar_class].map(&:text)
+  end
+
+  def test_children_in_source_order
+    obj = Parser::Source::Comment::Associator.new(nil, nil)
+    for_each_node do |node|
+      with_loc = node.children.select do |child|
+        child.is_a?(AST::Node) && child.loc && child.loc.expression
+      end
+      slow_sort = with_loc.sort_by.with_index do |child, index| # Index to ensure stable sort
+          [child.loc.expression.begin_pos, index]
+      end
+      optimized = obj.send(:children_in_source_order, node)
+      assert_equal slow_sort, optimized, "children_in_source_order incorrect for #{node}"
+    end
+  end
 end

data/test/test_source_map.rb

@@ -7,8 +7,7 @@ class TestSourceMap < Minitest::Test
   include ParseHelper
 
   def test_to_hash
-    buf = Parser::Source::Buffer.new("<input>")
-    buf.source = "1"
+    buf = Parser::Source::Buffer.new("<input>", source: "1")
     ast = parser_for_ruby_version('1.8').parse(buf)
     assert_equal [:expression, :operator], ast.loc.to_hash.keys.sort_by(&:to_s)
   end

data/test/test_source_range.rb

@@ -4,8 +4,8 @@ require 'helper'
 
 class TestSourceRange < Minitest::Test
   def setup
-    @buf = Parser::Source::Buffer.new('(string)')
-    @buf.source = "foobar\nbaz"
+    @buf = Parser::Source::Buffer.new('(string)',
+      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)
@@ -95,15 +95,15 @@ class TestSourceRange < Minitest::Test
 
   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 <=> @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, @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_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
@@ -155,6 +155,11 @@ class TestSourceRange < Minitest::Test
     refute sr.is?('bar')
   end
 
+  def test_to_range
+    sr = Parser::Source::Range.new(@buf, 10, 20)
+    assert_equal (10...20), sr.to_range
+  end
+
   def test_to_s
     sr = Parser::Source::Range.new(@buf, 8, 9)
     assert_equal '(string):2:2', sr.to_s
@@ -169,4 +174,19 @@ class TestSourceRange < Minitest::Test
     assert_equal 1, sr3.begin_pos
     assert_equal 4, sr3.end_pos
   end
+
+  def test_eql_and_hash
+    assert_equal false, @sr1_3.eql?(@sr3_3)
+    assert @sr1_3.hash != @sr3_3.hash
+
+    also_1_3 = @sr3_3.with(begin_pos: 1)
+    assert_equal true, @sr1_3.eql?(also_1_3)
+    assert_equal @sr1_3.hash, also_1_3.hash
+
+    buf2 = Parser::Source::Buffer.new('(string)',
+      source: "foobar\nbaz")
+    from_other_buf = Parser::Source::Range.new(buf2, 1, 3)
+    assert_equal false, @sr1_3.eql?(from_other_buf)
+    assert @sr1_3.hash != from_other_buf.hash
+  end
 end

data/test/test_source_rewriter.rb

@@ -4,8 +4,8 @@ require 'helper'
 
 class TestSourceRewriter < Minitest::Test
   def setup
-    @buf = Parser::Source::Buffer.new('(rewriter)')
-    @buf.source = 'foo bar baz'
+    @buf = Parser::Source::Buffer.new('(rewriter)',
+      source: 'foo bar baz')
     Parser::Source::Rewriter.warned_of_deprecation = true
     @rewriter = Parser::Source::Rewriter.new(@buf)
   end
@@ -522,7 +522,7 @@ class TestSourceRewriter < Minitest::Test
       end
     end
 
-    assert_match /nested/i, error.message
+    assert_match(/nested/i, error.message)
   end
 
   def test_process_in_transaction_raises_error
@@ -532,7 +532,7 @@ class TestSourceRewriter < Minitest::Test
       end
     end
 
-    assert_match /transaction/, error.message
+    assert_match(/transaction/, error.message)
   end
 
   def silence_diagnostics

data/test/test_source_rewriter_action.rb

@@ -4,8 +4,8 @@ require 'helper'
 
 class TestSourceRewriterAction < Minitest::Test
   def setup
-    @buf = Parser::Source::Buffer.new('(rewriter_action)')
-    @buf.source = 'foo bar baz'
+    @buf = Parser::Source::Buffer.new('(rewriter_action)',
+      source: 'foo bar baz')
   end
 
   def range(from, len)

data/test/test_source_tree_rewriter.rb

@@ -3,25 +3,32 @@
 require 'helper'
 
 class TestSourceTreeRewriter < Minitest::Test
-  def setup
-    @buf = Parser::Source::Buffer.new('(rewriter)')
-    @buf.source = 'puts(:hello, :world)'
+  module Setup
+    def setup
+      @buf = Parser::Source::Buffer.new('(rewriter)',
+        source: 'puts(:hello, :world)')
 
-    @hello = range(5, 6)
-    @comma_space = range(11,2)
-    @world = range(13,6)
-  end
+      @hello = range(5, 6)
+      @ll = range(8, 2)
+      @comma_space = range(11,2)
+      @world = range(13,6)
+      @whole = range(0, @buf.source.length)
+    end
 
-  def range(from, len)
-    Parser::Source::Range.new(@buf, from, from + len)
+    def range(from, len = nil)
+      from, len = from.begin, from.end - from.begin unless len
+      Parser::Source::Range.new(@buf, from, from + len)
+    end
   end
 
+  include Setup
+
   # Returns either:
-  #  - String (Normal operation)
+  #  - yield rewriter
   #  - [diagnostic, ...] (Diagnostics)
   #  - Parser::ClobberingError
   #
-  def apply(actions, **policy)
+  def build(actions, **policy)
     diagnostics = []
     diags = -> { diagnostics.flatten.map(&:strip).join("\n") }
     rewriter = Parser::Source::TreeRewriter.new(@buf, **policy)
@@ -30,14 +37,23 @@ class TestSourceTreeRewriter < Minitest::Test
       rewriter.public_send(action, range, *args)
     end
     if diagnostics.empty?
-      rewriter.process
+      yield rewriter
     else
       diags.call
     end
-  rescue ::Parser::ClobberingError => e
+  rescue ::Parser::ClobberingError => _e
     [::Parser::ClobberingError, diags.call]
   end
 
+  # Returns either:
+  #  - String (Normal operation)
+  #  - [diagnostic, ...] (Diagnostics)
+  #  - Parser::ClobberingError
+  #
+  def apply(actions, **policy)
+    build(actions, **policy) { |rewriter| rewriter.process }
+  end
+
   # Expects ordered actions to be grouped together
   def check_actions(expected, grouped_actions, **policy)
     grouped_actions.permutation do |sequence|
@@ -140,6 +156,16 @@ DIAGNOSTIC
                             [:wrap, @hello, '[', ']']]
   end
 
+  def test_inserts_on_empty_ranges
+    assert_actions_result 'puts({x}:hello[y], :world)',
+      [:insert_before, @hello.begin, '{'],
+      [:replace, @hello.begin, 'x'],
+      [:insert_after, @hello.begin, '}'],
+      [:insert_before, @hello.end, '['],
+      [:replace, @hello.end, 'y'],
+      [:insert_after, @hello.end, ']']
+  end
+
   def test_replace_same_range
     assert_actions_result 'puts(:hey, :world)',
                            [[:replace, @hello, ':hi'],
@@ -170,4 +196,166 @@ DIAGNOSTIC
     rewriter = Parser::Source::TreeRewriter.new(@buf)
     assert_raises(IndexError) { rewriter.insert_before(range(0, 100), 'hola') }
   end
+
+  def test_empty
+    rewriter = Parser::Source::TreeRewriter.new(@buf)
+    assert_equal true, rewriter.empty?
+
+    # This is a trivial wrap
+    rewriter.wrap(range(2,3), '', '')
+    assert_equal true, rewriter.empty?
+
+    # This is a trivial deletion
+    rewriter.remove(range(2,0))
+    assert_equal true, rewriter.empty?
+
+    rewriter.remove(range(2,3))
+    assert_equal false, rewriter.empty?
+  end
+
+  # splits array into two groups, yield all such possible pairs of groups
+  # each_split([1, 2, 3, 4]) yields [1, 2], [3, 4];
+  #                            then [1, 3], [2, 4]
+  #                                 ...
+  #                     and finally [3, 4], [1, 2]
+  def each_split(array)
+    n = array.size
+    first_split_size = n.div(2)
+    splitting = (0...n).to_set
+    splitting.to_a.combination(first_split_size) do |indices|
+      yield array.values_at(*indices),
+            array.values_at(*(splitting - indices))
+    end
+  end
+
+  # Checks that `actions+extra` give the same result when
+  # made in order or from subgroups that are later merged.
+  # The `extra` actions are always added at the end of the second group.
+  #
+  def check_all_merge_possibilities(actions, extra, **policy)
+    expected = apply(actions + extra, **policy)
+
+    each_split(actions) do |actions_1, actions_2|
+      build(actions_1, **policy) do |rewriter_1|
+        build(actions_2 + extra, **policy) do |rewriter_2|
+          result = rewriter_1.merge(rewriter_2).process
+          assert_equal(expected, result,
+            "Group 1: #{actions_1.inspect}\n\n" +
+            "Group 2: #{(actions_2 + extra).inspect}"
+          )
+        end
+      end
+    end
+  end
+
+  def test_merge
+    check_all_merge_possibilities([
+      [:wrap, @whole, '<', '>'],
+      [:replace, @comma_space, ' => '],
+      [:wrap, @hello, '!', '!'],
+      # Following two wraps must have same value as they
+      # will be applied in different orders...
+      [:wrap, @hello.join(@world), '{', '}'],
+      [:wrap, @hello.join(@world), '{', '}'],
+      [:remove, @ll],
+      [:replace, @world, ':everybody'],
+      [:wrap, @world, '[', ']']
+    ],
+    [ # ... but this one is always going to be applied last (extra)
+      [:wrap, @hello.join(@world), '@', '@'],
+    ])
+  end
+
+  def representation_example
+    Parser::Source::TreeRewriter.new(@buf)
+      .wrap(range(1...10), '(', ')')
+      .insert_after(range(2...6), '!')
+      .replace(range(2...4), 'foo')
+      .remove(range(5...6))
+  end
+
+  def test_nested_actions
+    result = representation_example.as_nested_actions
+
+    assert_equal( [ [:wrap, 1...10, '(', ')'],
+                    [:wrap, 2...6, '', '!'],  # aka "insert_after"
+                    [:replace, 2...4, 'foo'],
+                    [:replace, 5...6, ''],  # aka "removal"
+                  ],
+                  result.each {|arr| arr[1] = arr[1].to_range }
+                )
+  end
+
+  def test_ordered_replacements
+    result = representation_example.as_replacements
+
+    assert_equal( [ [ 1...1, '('],
+                    [ 2...4, 'foo'],
+                    [ 5...6, ''],
+                    [ 6...6, '!'],
+                    [ 10...10, ')'],
+                  ],
+                  result.map {|r, s| [r.to_range, s]}
+                )
+  end
+end
+
+class TestSourceTreeRewriterImport < Minitest::Test
+  include TestSourceTreeRewriter::Setup
+  def setup
+    super
+    @buf2 = Parser::Source::Buffer.new('(rewriter 2)',
+      source: ':hello')
+
+    @rewriter = Parser::Source::TreeRewriter.new(@buf)
+
+    @rewriter2 = Parser::Source::TreeRewriter.new(@buf2)
+
+    @hello2 = range2(0, 6)
+    @ll2 = range2(3, 2)
+  end
+
+  def range2(from, len)
+    Parser::Source::Range.new(@buf2, from, from + len)
+  end
+
+  def test_import_with_offset
+    @rewriter2.wrap(@hello2, '[', ']')
+    @rewriter.wrap(@hello.join(@world), '{', '}')
+    @rewriter.import!(@rewriter2, offset: @hello.begin_pos)
+    assert_equal 'puts({[:hello], :world})', @rewriter.process
+  end
+
+  def test_import_with_offset_from_bigger_source
+    @rewriter2.wrap(@ll2, '[', ']')
+    @rewriter.wrap(@hello, '{', '}')
+    @rewriter2.import!(@rewriter, offset: -@hello.begin_pos)
+    assert_equal '{:he[ll]o}', @rewriter2.process
+  end
+
+  def test_import_with_offset_and_self
+    @rewriter.wrap(@ll, '[', ']')
+    @rewriter.import!(@rewriter, offset: +3)
+    @rewriter.replace(range(8,1), '**')
+    assert_equal 'puts(:he[**l]o[, ]:world)', @rewriter.process
+    @rewriter.import!(@rewriter, offset: -6)
+    assert_equal 'pu[**s]([:h]e[**l]o[, ]:world)', @rewriter.process
+  end
+
+  def test_import_with_invalid_offset
+    @rewriter.wrap(@ll, '[', ']')
+    m = @rewriter.dup.import!(@rewriter, offset: -@ll.begin_pos)
+    assert_equal '[pu]ts(:he[ll]o, :world)', m.process
+    off = @buf.source.size - @ll.end_pos
+    m = @rewriter.dup.import!(@rewriter, offset: off)
+    assert_equal 'puts(:he[ll]o, :worl[d)]', m.process
+    assert_raises { @rewriter.import!(@rewriter, offset: -@ll.begin_pos - 1) }
+    assert_raises { @rewriter.import!(@rewriter, offset: off + 1) }
+    assert_equal 'puts(:he[ll]o, :world)', @rewriter.process # Test atomicity of import!
+  end
+
+  def test_empty_import
+    assert_equal @rewriter, @rewriter.import!(@rewriter2)
+    assert_equal @rewriter, @rewriter.import!(@rewriter, offset: 42)
+  end
 end