parser 2.7.1.1 → 3.0.2.0

data/test/test_source_map.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-require 'helper'
-require 'parse_helper'
-
-class TestSourceMap < Minitest::Test
-  include ParseHelper
-
-  def test_to_hash
-    buf = Parser::Source::Buffer.new("<input>")
-    buf.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
-end

data/test/test_source_range.rb

@@ -1,187 +0,0 @@
-# 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
-    assert_equal 1, @sr1_3.begin_pos
-    assert_equal 3, @sr1_3.end_pos
-    assert @sr1_3.frozen?
-  end
-
-  def test_size
-    assert_equal 4, @sr2_6.size
-  end
-
-  def test_bad_size
-    assert_raises ArgumentError do
-      Parser::Source::Range.new(@buf, 2, 1)
-    end
-  end
-
-  def test_join
-    sr = @sr1_3.join(@sr5_8)
-
-    assert_equal 1, sr.begin_pos
-    assert_equal 8, sr.end_pos
-  end
-
-  def test_intersect
-    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
-
-  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
-    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
-
-  def test_crossing
-    check_relationship(:crossing?, @sr1_3, @sr2_6)
-  end
-
-  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
-
-  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
-    assert !@sr1_3.empty?
-    assert @sr2_2.empty?
-  end
-
-  def test_line
-    sr = Parser::Source::Range.new(@buf, 7, 8)
-    assert_equal 2, sr.line
-  end
-
-  def test_source_line
-    sr = Parser::Source::Range.new(@buf, 7, 8)
-    assert_equal 'baz', sr.source_line
-  end
-
-  def test_columns
-    sr = Parser::Source::Range.new(@buf, 7, 8)
-    assert_equal 0, sr.begin.column
-    assert_equal 1, sr.end.column
-    assert_equal 0...1, sr.column_range
-  end
-
-  def test_begin_end
-    sr_beg = @sr2_6.begin
-    assert_equal 2, sr_beg.begin_pos
-    assert_equal 2, sr_beg.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
-    sr = Parser::Source::Range.new(@buf, 0, 3)
-    assert_equal 'foo', sr.source
-
-    sr_multi = Parser::Source::Range.new(@buf, 0, 10)
-    assert_equal "foobar\nbaz", sr_multi.source
-  end
-
-  def test_is?
-    sr = Parser::Source::Range.new(@buf, 0, 3)
-    assert sr.is?('foo')
-    refute sr.is?('bar')
-  end
-
-  def test_to_s
-    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
-
-  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)')
-    buf2.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

@@ -1,541 +0,0 @@
-# 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
-
-  def range(from, len)
-    Parser::Source::Range.new(@buf, from, from + len)
-  end
-
-  def test_remove
-    assert_equal 'foo  baz',
-                 @rewriter.
-                    remove(range(4, 3)).
-                    process
-  end
-
-  def test_insert_before
-    assert_equal 'foo quux bar baz',
-                 @rewriter.
-                    insert_before(range(4, 3), 'quux ').
-                    process
-  end
-
-  def test_insert_after
-    assert_equal 'foo bar quux baz',
-                 @rewriter.
-                    insert_after(range(4, 3), ' quux').
-                    process
-  end
-
-  def test_replace
-    assert_equal 'foo quux baz',
-                 @rewriter.
-                    replace(range(4, 3), 'quux').
-                    process
-  end
-
-  def test_composing_asc
-    assert_equal 'foo---bar---baz',
-                 @rewriter.
-                    replace(range(3, 1), '---').
-                    replace(range(7, 1), '---').
-                    process
-  end
-
-  def test_composing_desc
-    assert_equal 'foo---bar---baz',
-                 @rewriter.
-                    replace(range(7, 1), '---').
-                    replace(range(3, 1), '---').
-                    process
-  end
-
-  #
-  # Merging/clobbering of overlapping edits
-  #
-
-  def test_insertion_just_before_replace
-    assert_equal 'foostrawberry jam---bar baz',
-      @rewriter.
-        replace(range(3, 1), '---').
-        insert_before(range(3, 1), 'strawberry jam').
-        process
-  end
-
-  def test_insertion_just_after_replace
-    assert_equal 'foo---strawberry jam baz',
-      @rewriter.
-        replace(range(3, 4), '---').
-        insert_after(range(3, 4), 'strawberry jam').
-        process
-  end
-
-  def test_insertion_just_before_remove
-    assert_equal 'foostrawberry jambar baz',
-      @rewriter.
-        remove(range(3, 1)).
-        insert_before(range(3, 1), 'strawberry jam').
-        process
-  end
-
-  def test_insertion_just_after_remove
-    assert_equal 'foostrawberry jam baz',
-      @rewriter.
-        remove(range(3, 4)).
-        insert_after(range(3, 4), 'strawberry jam').
-        process
-  end
-
-  def test_insertion_just_before_replace_at_buffer_start
-    assert_equal 'strawberry jam--- bar baz',
-      @rewriter.
-        replace(range(0, 3), '---').
-        insert_before(range(0, 1), 'strawberry jam').
-        process
-  end
-
-  def test_insertion_just_after_replace_at_buffer_end
-    assert_equal 'foo bar ---strawberry jam',
-      @rewriter.
-        replace(range(8, 3), '---').
-        insert_after(range(9, 2), 'strawberry jam').
-        process
-  end
-
-  def test_insertion_just_before_remove_at_buffer_start
-    assert_equal 'strawberry bar baz',
-      @rewriter.
-        remove(range(0, 3)).
-        insert_before(range(0, 1), 'strawberry').
-        process
-  end
-
-  def test_insertion_just_after_remove_at_buffer_end
-    assert_equal 'foo bar strawberry',
-      @rewriter.
-        remove(range(8, 3)).
-        insert_after(range(10, 1), 'strawberry').
-        process
-  end
-
-  def test_multiple_insertions_at_same_location_clobber
-    silence_diagnostics
-
-    assert_raises Parser::ClobberingError do
-      @rewriter.
-        insert_before(range(0, 11), '<').
-        insert_after( range(0, 11), '>').
-        insert_before(range(0, 7), '(')
-    end
-  end
-
-  def test_intentional_multiple_insertions_at_same_location
-    assert_equal 'foo [(bar)] baz',
-      @rewriter.
-        insert_before_multi(range(4, 0), '(').
-        insert_after_multi(range(7, 0), ')').
-        insert_before_multi(range(4, 0), '[').
-        insert_after_multi(range(7, 0), ']').
-        process
-  end
-
-  def test_insertion_within_replace_clobber
-    silence_diagnostics
-
-    assert_raises Parser::ClobberingError do
-      @rewriter.
-        replace(range(3, 2), '<').
-        insert_after(range(3, 1), '>')
-    end
-  end
-
-  def test_insertion_within_remove_clobber
-    silence_diagnostics
-
-    assert_raises Parser::ClobberingError do
-      @rewriter.
-        remove(range(3, 2)).
-        insert_after(range(3, 1), '>')
-    end
-  end
-
-  def test_replace_overlapping_insertion_clobber
-    silence_diagnostics
-
-    assert_raises Parser::ClobberingError do
-      @rewriter.
-        insert_after(range(3, 1), '>').
-        replace(range(3, 2), '<')
-    end
-  end
-
-  def test_remove_overlapping_insertion_clobber
-    silence_diagnostics
-
-    assert_raises Parser::ClobberingError do
-      @rewriter.
-        insert_after(range(3, 1), '>').
-        remove(range(3, 2))
-    end
-  end
-
-  def test_multi_insertion_within_replace_clobber
-    silence_diagnostics
-
-    assert_raises Parser::ClobberingError do
-      @rewriter.
-        replace(range(3, 2), '<').
-        insert_after_multi(range(3, 1), '>')
-    end
-  end
-
-  def test_multi_insertion_within_remove_clobber
-    silence_diagnostics
-
-    assert_raises Parser::ClobberingError do
-      @rewriter.
-        remove(range(3, 2)).
-        insert_after_multi(range(3, 1), '>')
-    end
-  end
-
-  def test_replace_overlapping_multi_insertion_clobber
-    silence_diagnostics
-
-    assert_raises Parser::ClobberingError do
-      @rewriter.
-        insert_after_multi(range(3, 1), '>').
-        replace(range(3, 2), '<')
-    end
-  end
-
-  def test_remove_overlapping_multi_insertion_clobber
-    silence_diagnostics
-
-    assert_raises Parser::ClobberingError do
-      @rewriter.
-        insert_after_multi(range(3, 1), '>').
-        remove(range(3, 2))
-    end
-  end
-
-  def test_insertion_on_merged_insertion_clobber
-    # 2 insertions at the same point clobber each other, even if the 1st one
-    # was merged with an adjacent edit, and even if the same text is being
-    # inserted
-
-    silence_diagnostics
-
-    assert_raises Parser::ClobberingError do
-      @rewriter.
-        insert_before(range(3, 1), '>').
-        remove(range(3, 2)).
-        insert_after(range(2, 1), '>')
-    end
-  end
-
-  def test_insertion_merge_with_overlapping_replace
-    assert_equal 'fo abc bar baz',
-      @rewriter.
-        insert_before(range(3, 1), 'abc').
-        replace(range(2, 2), ' abc ').
-        process
-  end
-
-  def test_replace_merge_with_overlapped_insertion
-    assert_equal 'fo abc bar baz',
-      @rewriter.
-        replace(range(2, 2), ' abc ').
-        insert_before(range(3, 1), 'abc').
-        process
-  end
-
-  def test_replace_same_begin_larger_than_replaced_range_matching
-    assert_equal 'foo supercalifragilistic baz',
-      @rewriter.
-        replace(range(4, 3), 'super').
-        replace(range(4, 3), 'supercalifragilistic').
-        process
-  end
-
-  def test_replace_same_begin_larger_than_replaced_range_non_matching
-    silence_diagnostics
-
-    assert_raises Parser::ClobberingError do
-      @rewriter.
-        replace(range(4, 3), 'super!').
-        replace(range(4, 3), 'supercalifragilistic')
-    end
-  end
-
-  def test_overlapping_replace_left_smaller_than_replaced_matching
-    assert_equal 'superbaz',
-      @rewriter.
-        replace(range(0, 7), 'super').
-        replace(range(2, 6), 'per').
-        process
-  end
-
-  def test_overlapping_replace_left_smaller_than_replaced_non_matching
-    silence_diagnostics
-
-    assert_raises Parser::ClobberingError do
-      @rewriter.
-        replace(range(0, 7), 'super').
-        replace(range(2, 8), 'perk')
-    end
-  end
-
-  def test_overlapping_replace_left_larger_right_smaller_matching
-    assert_equal 'foods baz',
-      @rewriter.
-        replace(range(1, 3), 'oods ').
-        replace(range(3, 6), 'ds b').
-        process
-  end
-
-  def test_overlapping_replace_left_larger_right_larger_matching
-    assert_equal 'foods abcdefghijklm',
-      @rewriter.
-        replace(range(1, 3), 'oods ').
-        replace(range(3, 8), 'ds abcdefghijklm').
-        process
-  end
-
-  def test_overlapping_replace_left_larger_right_smaller_non_matching
-    silence_diagnostics
-
-    assert_raises Parser::ClobberingError do
-      @rewriter.
-        replace(range(1, 3), 'oods ').
-        replace(range(3, 6), 'ds')
-    end
-  end
-
-  def test_overlapping_replace_left_larger_right_larger_non_matching
-    silence_diagnostics
-
-    assert_raises Parser::ClobberingError do
-      @rewriter.
-        replace(range(1, 3), 'oods b').
-        replace(range(3, 8), 'ds abcdefghijklm')
-    end
-  end
-
-  def test_subsuming_replace_both_smaller_matching
-    assert_equal 'food baz',
-      @rewriter.
-        replace(range(0, 7), 'food').
-        replace(range(3, 3), 'd').
-        process
-  end
-
-  def test_subsuming_replace_both_smaller_non_matching
-    silence_diagnostics
-
-    assert_raises Parser::ClobberingError do
-      @rewriter.
-        replace(range(0, 7), 'foo').
-        replace(range(3, 3), 'd')
-    end
-  end
-
-  def test_subsuming_replace_both_larger_matching
-    assert_equal 'foo barr baz',
-      @rewriter.
-        replace(range(0, 7), 'foo barr').
-        replace(range(3, 3), ' bar').
-        process
-  end
-
-  def test_subsuming_replace_both_larger_non_matching
-    silence_diagnostics
-
-    assert_raises Parser::ClobberingError do
-      @rewriter.
-        replace(range(0, 7), 'foo barr').
-        replace(range(3, 3), ' bar ')
-    end
-  end
-
-  def test_replaced_ranges_merge_when_furthest_right_range_is_not_furthest_left
-    # regression test; previously, when actions were merged, the resulting
-    # replaced range could be too small sometimes
-    assert_equal 'foo_***_***',
-      @rewriter.
-        replace(range(3, 1), '_').
-        replace(range(7, 1), '_').
-        replace(range(4, 7), '***_***').
-        process
-  end
-
-  def test_clobber
-    diagnostics = []
-    @rewriter.diagnostics.consumer = lambda do |diag|
-      diagnostics << diag
-    end
-
-    assert_raises Parser::ClobberingError do
-      @rewriter.
-        replace(range(3, 1), '---').
-        remove(range(3, 1))
-    end
-
-    assert_equal 2, diagnostics.count
-
-    assert_equal :error, diagnostics.first.level
-    assert_equal 'cannot remove 1 character(s)',
-                 diagnostics.first.message
-    assert_equal range(3, 1), diagnostics.first.location
-
-    assert_equal :note, diagnostics.last.level
-    assert_equal "clobbered by: replace 1 character(s) with \"---\"",
-                 diagnostics.last.message
-    assert_equal range(3, 1), diagnostics.last.location
-  end
-
-  def test_clobbering_error_backward_compatibility
-    silence_diagnostics
-
-    rescued = false
-
-    # We use begin..rescue..end here rather than #assert_raises
-    # since #assert_raises expects exact error class.
-    begin
-      @rewriter.
-        replace(range(3, 1), '---').
-        remove(range(3, 1))
-    rescue RuntimeError => error
-      rescued = true if error.message.include?('clobber')
-    end
-
-    assert rescued
-  end
-
-
-  def test_crossing_delete
-    assert_equal 'faz',
-                 @rewriter.
-                   remove(range(1, 4)).
-                   remove(range(6, 3)).
-                   remove(range(4, 3)).
-                   process
-  end
-
-  def test_overlapping_replace
-    assert_equal 'flippin flyin flapjackz',
-                 @rewriter.
-                   replace(range(1, 4), 'lippin f').
-                   replace(range(4, 4), 'pin flyin flap').
-                   replace(range(7, 3), ' flyin flapjack').
-                   process
-  end
-
-  def test_subsuming_delete
-    assert_equal 'foo',
-                 @rewriter.
-                   remove(range(6, 3)).
-                   remove(range(7, 2)).
-                   remove(range(3, 8)).
-                   process
-  end
-
-  def test_subsuming_replace
-    assert_equal 'freebie',
-                 @rewriter.
-                   replace(range(3, 3), 'ebi').
-                   replace(range(1, 10), 'reebie').
-                   replace(range(5, 2), 'ie').
-                   process
-  end
-
-  def test_equivalent_delete_insert_replace
-    # A deletion + insertion just before or after the deleted range is
-    # identical in every way to a replacement! So logically, they shouldn't
-    # conflict.
-    assert_equal 'tin bar baz',
-      @rewriter.
-        remove(range(0, 3)).  # ' bar baz'
-        insert_before(range(0, 1), 'tin'). # 'tin bar baz'
-        replace(range(0, 3), 'tin').
-        process
-  end
-
-  def test_transaction_returns_self
-    assert_equal @rewriter, @rewriter.transaction {}
-  end
-
-  def test_transaction_commit
-    silence_diagnostics
-
-    # Original: 'foo bar baz'
-
-    # Rewrite as 'foo BAR baz'
-    @rewriter.replace(range(4, 3), 'BAR')
-
-    # Rewrite as '( bar )'
-    @rewriter.transaction do
-      @rewriter.replace(range(0, 3), '(')
-      @rewriter.replace(range(8, 3), ')')
-    end
-
-    @rewriter.replace(range(3, 1), '_')
-    @rewriter.replace(range(7, 1), '_')
-
-    assert_equal '(_BAR_)', @rewriter.process
-  end
-
-  def test_transaction_rollback
-    silence_diagnostics
-
-    # Original: 'foo bar baz'
-
-    # Rewrite as 'foo bar BAZ'
-    @rewriter.replace(range(8, 3), 'BAZ')
-
-    assert_raises Parser::ClobberingError do
-      # Trying to rewrite as '( bar )', but it fails
-      @rewriter.transaction do
-        @rewriter.replace(range(0, 3), '(')
-        @rewriter.replace(range(8, 3), ')')
-      end
-    end
-
-    @rewriter.replace(range(0, 3), 'FOO')
-
-    assert_equal 'FOO bar BAZ', @rewriter.process
-  end
-
-  def test_nested_transaction_raises_error
-    error = assert_raises RuntimeError do
-      @rewriter.transaction do
-        @rewriter.transaction do
-        end
-      end
-    end
-
-    assert_match /nested/i, error.message
-  end
-
-  def test_process_in_transaction_raises_error
-    error = assert_raises RuntimeError do
-      @rewriter.transaction do
-        @rewriter.process
-      end
-    end
-
-    assert_match /transaction/, error.message
-  end
-
-  def silence_diagnostics
-    @rewriter.diagnostics.consumer = proc {}
-  end
-end