zuora_connect_ui 0.8.3 → 0.9.0

data/vendor/ruby/2.6.0/gems/parser-2.6.5.0/lib/parser/static_environment.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Parser
+
+  class StaticEnvironment
+    def initialize
+      reset
+    end
+
+    def reset
+      @variables = Set[]
+      @stack     = []
+    end
+
+    def extend_static
+      @stack.push(@variables)
+      @variables = Set[]
+
+      self
+    end
+
+    def extend_dynamic
+      @stack.push(@variables)
+      @variables = @variables.dup
+
+      self
+    end
+
+    def unextend
+      @variables = @stack.pop
+
+      self
+    end
+
+    def declare(name)
+      @variables.add(name.to_sym)
+
+      self
+    end
+
+    def declared?(name)
+      @variables.include?(name.to_sym)
+    end
+  end
+
+end

data/vendor/ruby/2.6.0/gems/parser-2.6.5.0/lib/parser/syntax_error.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Parser
+  ##
+  # {Parser::SyntaxError} is raised whenever parser detects a syntax error,
+  # similar to the standard SyntaxError class.
+  #
+  # @api public
+  #
+  # @!attribute [r] diagnostic
+  #  @return [Parser::Diagnostic]
+  #
+  class SyntaxError < StandardError
+    attr_reader :diagnostic
+
+    def initialize(diagnostic)
+      @diagnostic = diagnostic
+      super(diagnostic.message)
+    end
+  end
+end

data/vendor/ruby/2.6.0/gems/parser-2.6.5.0/lib/parser/tree_rewriter.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+module Parser
+
+  ##
+  # {Parser::TreeRewriter} offers a basic API that makes it easy to rewrite
+  # existing ASTs. It's built on top of {Parser::AST::Processor} and
+  # {Parser::Source::TreeRewriter}
+  #
+  # For example, assume you want to remove `do` tokens from a while statement.
+  # You can do this as following:
+  #
+  #     require 'parser/current'
+  #
+  #     class RemoveDo < Parser::TreeRewriter
+  #       def on_while(node)
+  #         # Check if the statement starts with "do"
+  #         if node.location.begin.is?('do')
+  #           remove(node.location.begin)
+  #         end
+  #       end
+  #     end
+  #
+  #     code = <<-EOF
+  #     while true do
+  #       puts 'hello'
+  #     end
+  #     EOF
+  #
+  #     ast           = Parser::CurrentRuby.parse code
+  #     buffer        = Parser::Source::Buffer.new('(example)')
+  #     buffer.source = code
+  #     rewriter      = RemoveDo.new
+  #
+  #     # Rewrite the AST, returns a String with the new form.
+  #     puts rewriter.rewrite(buffer, ast)
+  #
+  # This would result in the following Ruby code:
+  #
+  #     while true
+  #       puts 'hello'
+  #     end
+  #
+  # Keep in mind that {Parser::TreeRewriter} does not take care of indentation when
+  # inserting/replacing code so you'll have to do this yourself.
+  #
+  # See also [a blog entry](http://whitequark.org/blog/2013/04/26/lets-play-with-ruby-code/)
+  # describing rewriters in greater detail.
+  #
+  # @api public
+  #
+  class TreeRewriter < Parser::AST::Processor
+    ##
+    # Rewrites the AST/source buffer and returns a String containing the new
+    # version.
+    #
+    # @param [Parser::Source::Buffer] source_buffer
+    # @param [Parser::AST::Node] ast
+    # @param [Symbol] crossing_deletions:, different_replacements:, swallowed_insertions:
+    #                 policy arguments for TreeRewriter (optional)
+    # @return [String]
+    #
+    def rewrite(source_buffer,
+                ast,
+                **policy)
+      @source_rewriter = Parser::Source::TreeRewriter.new(source_buffer, **policy)
+
+      process(ast)
+
+      @source_rewriter.process
+    end
+
+    ##
+    # Returns `true` if the specified node is an assignment node, returns false
+    # otherwise.
+    #
+    # @param [Parser::AST::Node] node
+    # @return [Boolean]
+    #
+    def assignment?(node)
+      [:lvasgn, :ivasgn, :gvasgn, :cvasgn, :casgn].include?(node.type)
+    end
+
+    ##
+    # Removes the source range.
+    #
+    # @param [Parser::Source::Range] range
+    #
+    def remove(range)
+      @source_rewriter.remove(range)
+    end
+
+    ##
+    # Wraps the given source range with the given values.
+    #
+    # @param [Parser::Source::Range] range
+    # @param [String] content
+    #
+    def wrap(range, before, after)
+      @source_rewriter.wrap(range, before, after)
+    end
+
+    ##
+    # Inserts new code before the given source range.
+    #
+    # @param [Parser::Source::Range] range
+    # @param [String] content
+    #
+    def insert_before(range, content)
+      @source_rewriter.insert_before(range, content)
+    end
+
+    ##
+    # Inserts new code after the given source range.
+    #
+    # @param [Parser::Source::Range] range
+    # @param [String] content
+    #
+    def insert_after(range, content)
+      @source_rewriter.insert_after(range, content)
+    end
+
+    ##
+    # Replaces the code of the source range `range` with `content`.
+    #
+    # @param [Parser::Source::Range] range
+    # @param [String] content
+    #
+    def replace(range, content)
+      @source_rewriter.replace(range, content)
+    end
+  end
+
+end

data/vendor/ruby/2.6.0/gems/parser-2.6.5.0/lib/parser/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Parser
+  VERSION = '2.6.5.0'
+end

data/vendor/ruby/2.6.0/gems/parser-2.6.5.0/parser.gemspec

@@ -0,0 +1,51 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+require File.expand_path('../lib/parser/version', __FILE__)
+
+Gem::Specification.new do |spec|
+  spec.name          = 'parser'
+  spec.version       = Parser::VERSION
+  spec.authors       = ['whitequark']
+  spec.email         = ['whitequark@whitequark.org']
+  spec.description   = 'A Ruby parser written in pure Ruby.'
+  spec.summary       = spec.description
+  spec.homepage      = 'https://github.com/whitequark/parser'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files`.split + %w(
+                          lib/parser/lexer.rb
+                          lib/parser/ruby18.rb
+                          lib/parser/ruby19.rb
+                          lib/parser/ruby20.rb
+                          lib/parser/ruby21.rb
+                          lib/parser/ruby22.rb
+                          lib/parser/ruby23.rb
+                          lib/parser/ruby24.rb
+                          lib/parser/ruby25.rb
+                          lib/parser/ruby26.rb
+                          lib/parser/ruby27.rb
+                          lib/parser/macruby.rb
+                          lib/parser/rubymotion.rb
+                       )
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^test/})
+  spec.require_paths = ['lib']
+
+  spec.required_ruby_version = '>= 2.0.0'
+
+  spec.add_dependency             'ast',       '~> 2.4.0'
+
+  spec.add_development_dependency 'bundler',   '>= 1.15', '< 3.0.0'
+  spec.add_development_dependency 'rake',      '~> 10.0'
+  spec.add_development_dependency 'racc',      '= 1.4.15'
+  spec.add_development_dependency 'cliver',    '~> 0.3.2'
+
+  spec.add_development_dependency 'yard'
+  spec.add_development_dependency 'kramdown'
+
+  spec.add_development_dependency 'minitest',  '~> 5.10'
+  spec.add_development_dependency 'simplecov', '~> 0.15.1'
+
+  spec.add_development_dependency 'gauntlet'
+end

data/vendor/ruby/2.6.0/gems/parser-2.6.5.0/test/bug_163/fixtures/input.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+if(true)
+  puts "Hello, world!"
+end

data/vendor/ruby/2.6.0/gems/parser-2.6.5.0/test/bug_163/fixtures/output.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+if true
+  puts "Hello, world!"
+end

data/vendor/ruby/2.6.0/gems/parser-2.6.5.0/test/bug_163/rewriter.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+class Rewriter < Parser::Rewriter
+  def on_if(node)
+    # Crude, totally-not-usable-in-the-real-world code to remove optional
+    # parens from control keywords.
+    #
+    # In a perfect test scenario we'd simply make this a no-op, to demonstrate
+    # that the bug happens when any rewriter is loaded regardless of whether it
+    # actually changes anything but that makes assertions much harder to get
+    # right.  It's much easier to just show that the file did, or did not
+    # get changed.
+    if node.children[0].type == :begin
+      replace node.children[0].loc.begin, ' '
+      remove node.children[0].loc.end
+    end
+
+    super
+  end
+end

data/vendor/ruby/2.6.0/gems/parser-2.6.5.0/test/helper.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require 'tempfile'
+require 'minitest/test'
+
+require 'simplecov'
+
+if ENV.include?('COVERAGE') && SimpleCov.usable?
+  require_relative 'racc_coverage_helper'
+
+  RaccCoverage.start(
+    %w(
+      ruby18.y
+      ruby19.y
+      ruby20.y
+      ruby21.y
+      ruby22.y
+      ruby23.y
+      ruby24.y
+      ruby25.y
+      ruby26.y
+    ),
+    File.expand_path('../../lib/parser', __FILE__))
+
+  # Report results faster.
+  at_exit { RaccCoverage.stop }
+
+  SimpleCov.start do
+    self.formatter = SimpleCov::Formatter::MultiFormatter[
+      SimpleCov::Formatter::HTMLFormatter,
+    ]
+
+    add_group 'Grammars' do |source_file|
+      source_file.filename =~ %r{\.y$}
+    end
+
+    # Exclude the testsuite itself.
+    add_filter '/test/'
+
+    # Exclude generated files.
+    add_filter do |source_file|
+      source_file.filename =~ %r{/lib/parser/(lexer|ruby\d+|macruby|rubymotion)\.rb$}
+    end
+  end
+end
+
+# minitest/autorun must go after SimpleCov to preserve
+# correct order of at_exit hooks.
+require 'minitest/autorun'
+
+$LOAD_PATH.unshift(File.expand_path('../../lib', __FILE__))
+require 'parser'
+
+class Parser::AST::Node
+  def initialize(type, *)
+    raise "Type #{type} missing from Parser::Meta::NODE_TYPES" unless Parser::Meta::NODE_TYPES.include?(type)
+    super
+  end
+end

data/vendor/ruby/2.6.0/gems/parser-2.6.5.0/test/parse_helper.rb

@@ -0,0 +1,316 @@
+# frozen_string_literal: true
+
+module ParseHelper
+  include AST::Sexp
+
+  require 'parser/all'
+  require 'parser/macruby'
+  require 'parser/rubymotion'
+
+  ALL_VERSIONS = %w(1.8 1.9 2.0 2.1 2.2 2.3 2.4 2.5 2.6 2.7 mac ios)
+
+  def setup
+    @diagnostics = []
+
+    super if defined?(super)
+  end
+
+  def parser_for_ruby_version(version)
+    case version
+    when '1.8' then parser = Parser::Ruby18.new
+    when '1.9' then parser = Parser::Ruby19.new
+    when '2.0' then parser = Parser::Ruby20.new
+    when '2.1' then parser = Parser::Ruby21.new
+    when '2.2' then parser = Parser::Ruby22.new
+    when '2.3' then parser = Parser::Ruby23.new
+    when '2.4' then parser = Parser::Ruby24.new
+    when '2.5' then parser = Parser::Ruby25.new
+    when '2.6' then parser = Parser::Ruby26.new
+    when '2.7' then parser = Parser::Ruby27.new
+    when 'mac' then parser = Parser::MacRuby.new
+    when 'ios' then parser = Parser::RubyMotion.new
+    else raise "Unrecognized Ruby version #{version}"
+    end
+
+    parser.diagnostics.consumer = lambda do |diagnostic|
+      @diagnostics << diagnostic
+    end
+
+    parser
+  end
+
+  def with_versions(versions)
+    (versions & ALL_VERSIONS).each do |version|
+      @diagnostics.clear
+
+      parser = parser_for_ruby_version(version)
+      yield version, parser
+    end
+  end
+
+  def assert_source_range(begin_pos, end_pos, range, version, what)
+    assert range.is_a?(Parser::Source::Range),
+           "(#{version}) #{range.inspect}.is_a?(Source::Range) for #{what}"
+
+    assert_equal begin_pos, range.begin_pos,
+                 "(#{version}) begin of #{what}"
+
+    assert_equal end_pos, range.end_pos,
+                 "(#{version}) end of #{what}"
+  end
+
+  # Use like this:
+  # ~~~
+  # assert_parses(
+  #   s(:send, s(:lit, 10), :+, s(:lit, 20))
+  #   %q{10 + 20},
+  #   %q{~~~~~~~ expression
+  #     |   ^ operator
+  #     |     ~~ expression (lit)
+  #     },
+  #     %w(1.8 1.9) # optional
+  # )
+  # ~~~
+  def assert_parses(ast, code, source_maps='', versions=ALL_VERSIONS)
+    with_versions(versions) do |version, parser|
+      try_parsing(ast, code, parser, source_maps, version)
+    end
+
+    # Also try parsing with lexer set to use UTF-32LE internally
+    with_versions(versions) do |version, parser|
+      parser.instance_eval { @lexer.force_utf32 = true }
+      try_parsing(ast, code, parser, source_maps, version)
+    end
+  end
+
+  def try_parsing(ast, code, parser, source_maps, version)
+    source_file = Parser::Source::Buffer.new('(assert_parses)')
+    source_file.source = code
+
+    begin
+      parsed_ast = parser.parse(source_file)
+    rescue => exc
+      backtrace = exc.backtrace
+      Exception.instance_method(:initialize).bind(exc).
+        call("(#{version}) #{exc.message}")
+      exc.set_backtrace(backtrace)
+      raise
+    end
+
+    if ast.nil?
+      assert_nil parsed_ast, "(#{version}) AST equality"
+      return
+    end
+
+    assert_equal ast, parsed_ast,
+                 "(#{version}) AST equality"
+
+    parse_source_map_descriptions(source_maps) \
+        do |begin_pos, end_pos, map_field, ast_path, line|
+
+      astlet = traverse_ast(parsed_ast, ast_path)
+
+      if astlet.nil?
+        # This is a testsuite bug.
+        raise "No entity with AST path #{ast_path} in #{parsed_ast.inspect}"
+      end
+
+      assert astlet.frozen?
+
+      assert astlet.location.respond_to?(map_field),
+             "(#{version}) #{astlet.location.inspect}.respond_to?(#{map_field.inspect}) for:\n#{parsed_ast.inspect}"
+
+      range = astlet.location.send(map_field)
+
+      assert_source_range(begin_pos, end_pos, range, version, line.inspect)
+    end
+
+    assert parser.instance_eval { @lexer }.cmdarg.empty?,
+      "(#{version}) expected cmdarg to be empty after parsing"
+  end
+
+  # Use like this:
+  # ~~~
+  # assert_diagnoses(
+  #   [:warning, :ambiguous_prefix, { prefix: '*' }],
+  #   %q{foo *bar},
+  #   %q{    ^ location
+  #     |     ~~~ highlights (0)})
+  # ~~~
+  def assert_diagnoses(diagnostic, code, source_maps='', versions=ALL_VERSIONS)
+    with_versions(versions) do |version, parser|
+      source_file = Parser::Source::Buffer.new('(assert_diagnoses)')
+      source_file.source = code
+
+      begin
+        parser = parser.parse(source_file)
+      rescue Parser::SyntaxError
+        # do nothing; the diagnostic was reported
+      end
+
+      assert_equal 1, @diagnostics.count,
+                   "(#{version}) emits a single diagnostic, not\n" \
+                   "#{@diagnostics.map(&:render).join("\n")}"
+
+      emitted_diagnostic = @diagnostics.first
+
+      level, reason, arguments = diagnostic
+      arguments ||= {}
+      message     = Parser::MESSAGES[reason] % arguments
+
+      assert_equal level, emitted_diagnostic.level
+      assert_equal reason, emitted_diagnostic.reason
+      assert_equal arguments, emitted_diagnostic.arguments
+      assert_equal message, emitted_diagnostic.message
+
+      parse_source_map_descriptions(source_maps) \
+          do |begin_pos, end_pos, map_field, ast_path, line|
+
+        case map_field
+        when 'location'
+          assert_source_range begin_pos, end_pos,
+                              emitted_diagnostic.location,
+                              version, 'location'
+
+        when 'highlights'
+          index = ast_path.first.to_i
+
+          assert_source_range begin_pos, end_pos,
+                              emitted_diagnostic.highlights[index],
+                              version, "#{index}th highlight"
+
+        else
+          raise "Unknown diagnostic range #{map_field}"
+        end
+      end
+    end
+  end
+
+  # Use like this:
+  # ~~~
+  # assert_diagnoses_many(
+  #   [
+  #     [:warning, :ambiguous_literal],
+  #     [:error, :unexpected_token, { :token => :tLCURLY }]
+  #   ],
+  #   %q{m /foo/ {}},
+  #   SINCE_2_4)
+  # ~~~
+  def assert_diagnoses_many(diagnostics, code, versions=ALL_VERSIONS)
+    with_versions(versions) do |version, parser|
+      source_file = Parser::Source::Buffer.new('(assert_diagnoses_many)')
+      source_file.source = code
+
+      begin
+        parser = parser.parse(source_file)
+      rescue Parser::SyntaxError
+        # do nothing; the diagnostic was reported
+      end
+
+      assert_equal diagnostics.count, @diagnostics.count
+
+      diagnostics.zip(@diagnostics) do |expected_diagnostic, actual_diagnostic|
+        level, reason, arguments = expected_diagnostic
+        arguments ||= {}
+        message     = Parser::MESSAGES[reason] % arguments
+
+        assert_equal level, actual_diagnostic.level
+        assert_equal reason, actual_diagnostic.reason
+        assert_equal arguments, actual_diagnostic.arguments
+        assert_equal message, actual_diagnostic.message
+      end
+    end
+  end
+
+  def refute_diagnoses(code, versions=ALL_VERSIONS)
+    with_versions(versions) do |version, parser|
+      source_file = Parser::Source::Buffer.new('(refute_diagnoses)')
+      source_file.source = code
+
+      begin
+        parser = parser.parse(source_file)
+      rescue Parser::SyntaxError
+        # do nothing; the diagnostic was reported
+      end
+
+      assert_empty @diagnostics,
+                   "(#{version}) emits no diagnostics, not\n" \
+                   "#{@diagnostics.map(&:render).join("\n")}"
+    end
+  end
+
+  def assert_context(context, code, versions=ALL_VERSIONS)
+    with_versions(versions) do |version, parser|
+      source_file = Parser::Source::Buffer.new('(assert_context)')
+      source_file.source = code
+
+      begin
+        parser.parse(source_file)
+      rescue Parser::SyntaxError
+        # do nothing; the diagnostic was reported
+      end
+
+      assert_equal parser.context.stack, context, "(#{version}) parsing context"
+    end
+  end
+
+  SOURCE_MAP_DESCRIPTION_RE =
+      /(?x)
+       ^(?# $1 skip)            ^(\s*)
+        (?# $2 highlight)        ([~\^]+)
+                                 \s+
+        (?# $3 source_map_field) ([a-z_]+)
+        (?# $5 ast_path)         (\s+\(([a-z_.\/0-9]+)\))?
+                                $/
+
+  def parse_source_map_descriptions(descriptions)
+    unless block_given?
+      return to_enum(:parse_source_map_descriptions, descriptions)
+    end
+
+    descriptions.each_line do |line|
+      # Remove leading "     |", if it exists.
+      line = line.sub(/^\s*\|/, '').rstrip
+
+      next if line.empty?
+
+      if (match = SOURCE_MAP_DESCRIPTION_RE.match(line))
+        begin_pos        = match[1].length
+        end_pos          = begin_pos + match[2].length
+        source_map_field = match[3]
+
+        if match[5]
+          ast_path = match[5].split('.')
+        else
+          ast_path = []
+        end
+
+        yield begin_pos, end_pos, source_map_field, ast_path, line
+      else
+        raise "Cannot parse source map description line: #{line.inspect}."
+      end
+    end
+  end
+
+  def traverse_ast(ast, path)
+    path.inject(ast) do |astlet, path_component|
+      # Split "dstr/2" to :dstr and 1
+      type_str, index_str = path_component.split('/')
+
+      type  = type_str.to_sym
+
+      if index_str.nil?
+        index = 0
+      else
+        index = index_str.to_i - 1
+      end
+
+      matching_children = \
+        astlet.children.select do |child|
+          AST::Node === child && child.type == type
+        end
+
+      matching_children[index]
+    end
+  end
+end