zuora_connect_ui 0.8.2 → 0.8.3

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

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require 'helper'
+require 'open3'
+
+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)
+
+    assert_equal 0, status.to_i
+    assert_includes(stdout, expected_output)
+  end
+
+  def test_emit_ruby
+    assert_prints ['--emit-ruby', '-e 123'],
+                  's(:int, 123)'
+  end
+
+  def test_emit_json
+    assert_prints ['--emit-json', '-e', '123'],
+                  '["int",123]'
+  end
+
+  def test_emit_ruby_empty
+    assert_prints ['--emit-ruby', '-e', ''],
+                  "\n"
+  end
+
+  def test_emit_json_empty
+    assert_prints ['--emit-json', '-e', ''],
+                  "\n"
+  end
+end

data/vendor/ruby/2.6.0/gems/parser-2.6.4.1/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/vendor/ruby/2.6.0/gems/parser-2.6.4.1/test/test_source_buffer.rb

@@ -0,0 +1,162 @@
+# frozen_string_literal: true
+
+require 'helper'
+
+class TestSourceBuffer < Minitest::Test
+  def setup
+    @buffer = Parser::Source::Buffer.new('(string)')
+  end
+
+  def test_initialize
+    buffer = Parser::Source::Buffer.new(nil)
+    assert_equal '', buffer.name
+
+    buffer = Parser::Source::Buffer.new(Pathname('a/b'))
+    assert_equal 'a/b', buffer.name
+
+    buffer = Parser::Source::Buffer.new('(string)')
+    assert_equal '(string)', buffer.name
+    assert_equal 1, buffer.first_line
+
+    buffer = Parser::Source::Buffer.new('(string)', 5)
+    assert_equal 5, buffer.first_line
+  end
+
+  def test_source_setter
+    @buffer.source = 'foo'
+    assert_equal 'foo', @buffer.source
+
+    assert @buffer.source.frozen?
+  end
+
+  def test_source_double_setter
+    @buffer.source = 'foo'
+
+    assert_raises(ArgumentError) do
+      @buffer.source = 'bar'
+    end
+  end
+
+  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
+    tempfile = Tempfile.new('parser')
+    tempfile.write('foobar')
+    tempfile.flush
+
+    buffer = Parser::Source::Buffer.new(tempfile.path)
+    buffer.read
+    assert_equal 'foobar', buffer.source
+
+    assert buffer.source.frozen?
+  end
+
+  def test_uninitialized
+    assert_raises RuntimeError do
+      @buffer.source
+    end
+  end
+
+  def test_decompose_position
+    @buffer.source = "1\nfoo\nbar"
+
+    assert_equal [1, 0], @buffer.decompose_position(0)
+    assert_equal [1, 1], @buffer.decompose_position(1)
+    assert_equal [2, 0], @buffer.decompose_position(2)
+    assert_equal [3, 1], @buffer.decompose_position(7)
+  end
+
+  def test_decompose_position_mapped
+    @buffer = Parser::Source::Buffer.new('(string)', 5)
+    @buffer.source = "1\nfoo\nbar"
+
+    assert_equal [5, 0], @buffer.decompose_position(0)
+    assert_equal [6, 0], @buffer.decompose_position(2)
+  end
+
+  def test_line
+    @buffer.source = "1\nfoo\nbar"
+
+    assert_equal '1', @buffer.source_line(1)
+    assert_equal 'foo', @buffer.source_line(2)
+  end
+
+  def test_line_mutate
+    @buffer.source = "1\nfoo\nbar"
+
+    assert_equal '1', @buffer.source_line(1)
+
+    @buffer.source_line(1)[0] = '2'
+    assert_equal '1', @buffer.source_line(1)
+  end
+
+  def test_line_mapped
+    @buffer = Parser::Source::Buffer.new('(string)', 5)
+    @buffer.source = "1\nfoo\nbar"
+
+    assert_equal '1', @buffer.source_line(5)
+    assert_equal 'foo', @buffer.source_line(6)
+  end
+
+  def test_line_range
+    @buffer = Parser::Source::Buffer.new('(string)', 5)
+    @buffer.source = "abc\ndef\nghi\n"
+
+    assert_raises IndexError do
+      @buffer.line_range(4)
+    end
+    assert_equal 'abc', @buffer.line_range(5).source
+    assert_equal 'def', @buffer.line_range(6).source
+    assert_equal 'ghi', @buffer.line_range(7).source
+    assert_equal '', @buffer.line_range(8).source
+    assert_raises IndexError do
+      @buffer.line_range(9)
+    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
+
+    @buffer = Parser::Source::Buffer.new('(string)', 5)
+    @buffer.source = ""
+    assert_equal 5, @buffer.last_line
+
+    @buffer = Parser::Source::Buffer.new('(string)', 5)
+    @buffer.source = "abc\n"
+    assert_equal 6, @buffer.last_line
+  end
+
+  def test_source_lines
+    @buffer.source = "1\nfoo\nbar\n"
+
+    assert_equal ['1', 'foo', 'bar', ''], @buffer.source_lines
+    assert @buffer.source_lines.frozen?
+    assert @buffer.source_lines.all?(&:frozen?)
+
+    @buffer = Parser::Source::Buffer.new('(string)', 5)
+    @buffer.source = "foo\nbar"
+    assert_equal ['foo', 'bar'], @buffer.source_lines
+  end
+end

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+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"
+  end
+
+  def range(s, e)
+    Parser::Source::Range.new(@buf, s, e)
+  end
+
+  def test_initialize
+    comment = Parser::Source::Comment.new(range(0, 5))
+    assert comment.frozen?
+  end
+
+  def test_text
+    comment = Parser::Source::Comment.new(range(0, 5))
+    assert_equal '# foo', comment.text
+  end
+
+  def test_inline
+    comment = Parser::Source::Comment.new(range(0, 5))
+    assert_equal :inline, comment.type
+    assert comment.inline?
+  end
+
+  def test_document
+    comment = Parser::Source::Comment.new(range(6, 25))
+    assert_equal :document, comment.type
+    assert comment.document?
+  end
+end

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

@@ -0,0 +1,367 @@
+# frozen_string_literal: true
+
+require 'helper'
+require 'parser/ruby18'
+
+class TestSourceCommentAssociator < Minitest::Test
+  def parse_with_comments(code)
+    parser = Parser::Ruby18.new
+
+    buffer = Parser::Source::Buffer.new('(comments)')
+    buffer.source = code
+
+    parser.parse_with_comments(buffer)
+  end
+
+  def associate(code)
+    ast, comments = parse_with_comments(code)
+    associations  = Parser::Source::Comment.associate(ast, comments)
+
+    [ ast, associations ]
+  end
+
+  def associate_locations(code)
+    ast, comments = parse_with_comments(code)
+    associations  = Parser::Source::Comment.associate_locations(ast, comments)
+
+    [ ast, associations ]
+  end
+
+  def test_associate
+    ast, associations = associate(<<-END)
+#!/usr/bin/env ruby
+# coding: utf-8
+# class preceeding
+# another class preceeding
+class Foo # class keyword line
+  # method foo preceeding
+  def foo
+    puts 'foo'
+  end # method foo decorating
+  # method bar preceeding
+  def bar
+    # expression preceeding
+    1 + # 1 decorating
+      2
+    # method bar sparse
+  end # method bar decorating
+  # class sparse
+end # class decorating
+    END
+
+    klass_node      = ast
+    klass_name_node = klass_node.children[0]
+    foo_node        = klass_node.children[2].children[0] # def foo
+    bar_node        = klass_node.children[2].children[1] # def bar
+    expr_node       = bar_node.children[2] # 1 + 2
+    one_node        = expr_node.children[0] # 1
+
+    assert_equal 6, associations.size
+    assert_equal [
+      '# class preceeding',
+      '# another class preceeding',
+      '# class sparse',
+      '# class decorating'
+    ], associations[klass_node].map(&:text)
+    assert_equal [
+      '# class keyword line'
+    ], associations[klass_name_node].map(&:text)
+    assert_equal [
+      '# method foo preceeding',
+      '# method foo decorating'
+    ], associations[foo_node].map(&:text)
+    assert_equal [
+      '# method bar preceeding',
+      '# method bar sparse',
+      '# method bar decorating'
+    ], associations[bar_node].map(&:text)
+    assert_equal [
+      '# expression preceeding'
+    ], associations[expr_node].map(&:text)
+    assert_equal [
+      '# 1 decorating'
+    ], associations[one_node].map(&:text)
+  end
+
+  # The bug below is fixed by using associate_locations
+  def test_associate_dupe_statement
+    ast, associations = associate(<<-END)
+class Foo
+  def bar
+    f1 # comment on 1st call to f1
+    f2
+    f1 # comment on 2nd call to f1
+  end
+end
+    END
+
+    klass_node         = ast
+    method_node        = ast.children[2]
+    body               = method_node.children[2]
+    f1_1_node          = body.children[0]
+    f1_2_node          = body.children[2]
+
+    assert_equal 1, associations.size
+    assert_equal ['# comment on 1st call to f1', '# comment on 2nd call to f1'],
+                 associations[f1_1_node].map(&:text)
+    assert_equal ['# comment on 1st call to f1', '# comment on 2nd call to f1'],
+                 associations[f1_2_node].map(&:text)
+  end
+
+  def test_associate_locations
+    ast, associations = associate_locations(<<-END)
+#!/usr/bin/env ruby
+# coding: utf-8
+# class preceeding
+# another class preceeding
+class Foo # class keyword line
+  # method foo preceeding
+  def foo
+    puts 'foo'
+  end # method foo decorating
+  # method bar preceeding
+  def bar
+    # expression preceeding
+    1 + # 1 decorating
+      2
+    # method bar sparse
+  end # method bar decorating
+  # class sparse
+end # class decorating
+    END
+
+    klass_node      = ast
+    klass_name_node = klass_node.children[0]
+    foo_node        = klass_node.children[2].children[0] # def foo
+    bar_node        = klass_node.children[2].children[1] # def bar
+    expr_node       = bar_node.children[2] # 1 + 2
+    one_node        = expr_node.children[0] # 1
+
+    assert_equal 6, associations.size
+    assert_equal [
+      '# class preceeding',
+      '# another class preceeding',
+      '# class sparse',
+      '# class decorating'
+    ], associations[klass_node.loc].map(&:text)
+    assert_equal [
+      '# class keyword line'
+    ], associations[klass_name_node.loc].map(&:text)
+    assert_equal [
+      '# method foo preceeding',
+      '# method foo decorating'
+    ], associations[foo_node.loc].map(&:text)
+    assert_equal [
+      '# method bar preceeding',
+      '# method bar sparse',
+      '# method bar decorating'
+    ], associations[bar_node.loc].map(&:text)
+    assert_equal [
+      '# expression preceeding'
+    ], associations[expr_node.loc].map(&:text)
+    assert_equal [
+      '# 1 decorating'
+    ], associations[one_node.loc].map(&:text)
+  end
+
+  def test_associate_locations_dupe_statement
+    ast, associations = associate_locations(<<-END)
+class Foo
+  def bar
+    f1 # comment on 1st call to f1
+    f2
+    f1 # comment on 2nd call to f1
+  end
+end
+    END
+
+    klass_node         = ast
+    method_node        = ast.children[2]
+    body               = method_node.children[2]
+    f1_1_node          = body.children[0]
+    f1_2_node          = body.children[2]
+
+    assert_equal 2, associations.size
+    assert_equal ['# comment on 1st call to f1'],
+                 associations[f1_1_node.loc].map(&:text)
+    assert_equal ['# comment on 2nd call to f1'],
+                 associations[f1_2_node.loc].map(&:text)
+  end
+
+  def test_associate_no_body
+    ast, associations = associate(<<-END)
+# foo
+class Foo
+end
+    END
+
+    assert_equal 1, associations.size
+    assert_equal ['# foo'],
+                 associations[ast].map(&:text)
+  end
+
+  def test_associate_empty_tree
+    ast, associations = associate("")
+    assert_equal 0, associations.size
+  end
+
+  def test_associate_shebang_only
+    ast, associations = associate(<<-END)
+#!ruby
+class Foo
+end
+    END
+
+    assert_equal 0, associations.size
+  end
+
+  def test_associate_frozen_string_literal
+    ast, associations = associate(<<-END)
+# frozen_string_literal: true
+class Foo
+end
+    END
+
+    assert_equal 0, associations.size
+  end
+
+  def test_associate_frozen_string_literal_dash_star_dash
+    ast, associations = associate(<<-END)
+# -*- frozen_string_literal: true -*-
+class Foo
+end
+    END
+
+    assert_equal 0, associations.size
+  end
+
+  def test_associate_frozen_string_literal_no_space_after_colon
+    ast, associations = associate(<<-END)
+# frozen_string_literal:true
+class Foo
+end
+    END
+
+    assert_equal 0, associations.size
+  end
+
+  def test_associate_warn_indent
+    ast, associations = associate(<<-END)
+# warn_indent: true
+class Foo
+end
+    END
+
+    assert_equal 0, associations.size
+  end
+
+  def test_associate_warn_indent_dash_star_dash
+    ast, associations = associate(<<-END)
+# -*- warn_indent: true -*-
+class Foo
+end
+    END
+
+    assert_equal 0, associations.size
+  end
+
+  def test_associate_warn_past_scope
+    ast, associations = associate(<<-END)
+# warn_past_scope: true
+class Foo
+end
+    END
+
+    assert_equal 0, associations.size
+  end
+
+  def test_associate_warn_past_scope_dash_star_dash
+    ast, associations = associate(<<-END)
+# -*- warn_past_scope: true -*-
+class Foo
+end
+    END
+
+    assert_equal 0, associations.size
+  end
+
+  def test_associate_multiple
+    ast, associations = associate(<<-END)
+# frozen_string_literal: true; warn_indent: true
+class Foo
+end
+    END
+
+    assert_equal 0, associations.size
+  end
+
+  def test_associate_multiple_dash_star_dash
+    ast, associations = associate(<<-END)
+# -*- frozen_string_literal: true; warn_indent: true -*-
+class Foo
+end
+    END
+
+    assert_equal 0, associations.size
+  end
+
+  def test_associate_no_comments
+    ast, associations = associate(<<-END)
+class Foo
+end
+    END
+
+    assert_equal 0, associations.size
+  end
+
+  def test_associate_comments_after_root_node
+    ast, associations = associate(<<-END)
+class Foo
+end
+# not associated
+    END
+
+    assert_equal 0, associations.size
+  end
+
+
+  def test_associate_stray_comment
+    ast, associations = associate(<<-END)
+def foo
+  # foo
+end
+    END
+
+    assert_equal 1, associations.size
+    assert_equal ['# foo'],
+                 associations[ast].map(&:text)
+  end
+
+  def test_associate___ENCODING__
+    ast, associations = associate(<<-END)
+# foo
+__ENCODING__
+    END
+
+    assert_equal 1, associations.size
+    assert_equal ['# foo'],
+                 associations[ast].map(&:text)
+  end
+
+  def test_associate_inside_heredoc
+    ast, associations = associate(<<-END)
+<<x
+\#{
+  foo # bar
+}
+x
+    END
+
+    begin_node = ast.children[0]
+    send_node  = begin_node.children[0]
+
+    assert_equal 1, associations.size
+    assert_equal ['# bar'],
+                 associations[send_node].map(&:text)
+  end
+end