zuora_connect_ui 0.8.2 → 0.8.3

data/vendor/ruby/2.6.0/gems/parser-2.6.4.1/test/test_source_map.rb

@@ -0,0 +1,15 @@
+# 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/vendor/ruby/2.6.0/gems/parser-2.6.4.1/test/test_source_range.rb

@@ -0,0 +1,172 @@
+# 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
+end

data/vendor/ruby/2.6.0/gems/parser-2.6.4.1/test/test_source_rewriter.rb

@@ -0,0 +1,541 @@
+# 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