plaid 14.11.0 → 14.11.1

data/vendor/bundle/ruby/2.6.0/gems/regexp_parser-1.8.0/spec/scanner/sets_spec.rb

@@ -0,0 +1,102 @@
+require 'spec_helper'
+
+RSpec.describe('Set scanning') do
+  include_examples 'scan', /[a]/,                   0 => [:set,    :open,            '[',          0, 1]
+  include_examples 'scan', /[b]/,                   2 => [:set,    :close,           ']',          2, 3]
+  include_examples 'scan', /[^n]/,                  1 => [:set,    :negate,          '^',          1, 2]
+
+  include_examples 'scan', /[c]/,                   1 => [:literal, :literal,        'c',          1, 2]
+  include_examples 'scan', /[\b]/,                  1 => [:escape,  :backspace,      '\b',         1, 3]
+  include_examples 'scan', /[A\bX]/,                2 => [:escape,  :backspace,      '\b',         2, 4]
+
+  include_examples 'scan', /[.]/,                   1 => [:literal, :literal,        '.',          1, 2]
+  include_examples 'scan', /[?]/,                   1 => [:literal, :literal,        '?',          1, 2]
+  include_examples 'scan', /[*]/,                   1 => [:literal, :literal,        '*',          1, 2]
+  include_examples 'scan', /[+]/,                   1 => [:literal, :literal,        '+',          1, 2]
+  include_examples 'scan', /[{]/,                   1 => [:literal, :literal,        '{',          1, 2]
+  include_examples 'scan', /[}]/,                   1 => [:literal, :literal,        '}',          1, 2]
+  include_examples 'scan', /[<]/,                   1 => [:literal, :literal,        '<',          1, 2]
+  include_examples 'scan', /[>]/,                   1 => [:literal, :literal,        '>',          1, 2]
+
+  include_examples 'scan', /[äöü]/,                 2 => [:literal, :literal,        'ö',          3, 5]
+
+  include_examples 'scan', /[\x20]/,                1 => [:escape, :hex,             '\x20',       1, 5]
+
+  include_examples 'scan', '[\.]',                  1 => [:escape, :dot,             '\.',         1, 3]
+  include_examples 'scan', '[\!]',                  1 => [:escape, :literal,         '\!',         1, 3]
+  include_examples 'scan', '[\#]',                  1 => [:escape, :literal,         '\#',         1, 3]
+  include_examples 'scan', '[\\]]',                 1 => [:escape, :set_close,       '\]',         1, 3]
+  include_examples 'scan', '[\\\\]',                1 => [:escape, :backslash,       '\\\\',       1, 3]
+  include_examples 'scan', '[\A]',                  1 => [:escape, :literal,         '\A',         1, 3]
+  include_examples 'scan', '[\z]',                  1 => [:escape, :literal,         '\z',         1, 3]
+  include_examples 'scan', '[\g]',                  1 => [:escape, :literal,         '\g',         1, 3]
+  include_examples 'scan', '[\K]',                  1 => [:escape, :literal,         '\K',         1, 3]
+  include_examples 'scan', '[\R]',                  1 => [:escape, :literal,         '\R',         1, 3]
+  include_examples 'scan', '[\X]',                  1 => [:escape, :literal,         '\X',         1, 3]
+  include_examples 'scan', '[\c2]',                 1 => [:escape, :literal,         '\c',         1, 3]
+  include_examples 'scan', '[\B]',                  1 => [:escape, :literal,         '\B',         1, 3]
+  include_examples 'scan', '[a\-c]',                2 => [:escape, :literal,         '\-',         2, 4]
+
+  include_examples 'scan', /[\d]/,                  1 => [:type,   :digit,           '\d',         1, 3]
+  include_examples 'scan', /[\da-z]/,               1 => [:type,   :digit,           '\d',         1, 3]
+  include_examples 'scan', /[\D]/,                  1 => [:type,   :nondigit,        '\D',         1, 3]
+
+  include_examples 'scan', /[\h]/,                  1 => [:type,   :hex,             '\h',         1, 3]
+  include_examples 'scan', /[\H]/,                  1 => [:type,   :nonhex,          '\H',         1, 3]
+
+  include_examples 'scan', /[\s]/,                  1 => [:type,   :space,           '\s',         1, 3]
+  include_examples 'scan', /[\S]/,                  1 => [:type,   :nonspace,        '\S',         1, 3]
+
+  include_examples 'scan', /[\w]/,                  1 => [:type,   :word,            '\w',         1, 3]
+  include_examples 'scan', /[\W]/,                  1 => [:type,   :nonword,         '\W',         1, 3]
+
+  include_examples 'scan', /[a-b]/,                 1 => [:literal, :literal,        'a',          1, 2]
+  include_examples 'scan', /[a-c]/,                 2 => [:set,     :range,          '-',          2, 3]
+  include_examples 'scan', /[a-d]/,                 3 => [:literal, :literal,        'd',          3, 4]
+  include_examples 'scan', /[a-b-]/,                4 => [:literal, :literal,        '-',          4, 5]
+  include_examples 'scan', /[-a]/,                  1 => [:literal, :literal,        '-',          1, 2]
+  include_examples 'scan', /[a-c^]/,                4 => [:literal, :literal,        '^',          4, 5]
+  include_examples 'scan', /[a-bd-f]/,              2 => [:set,    :range,           '-',          2, 3]
+  include_examples 'scan', /[a-cd-f]/,              5 => [:set,    :range,           '-',          5, 6]
+
+  include_examples 'scan', /[a[:digit:]c]/,         2 => [:posixclass,    :digit,    '[:digit:]',  2, 11]
+  include_examples 'scan', /[[:digit:][:space:]]/,  2 => [:posixclass,    :space,    '[:space:]', 10, 19]
+  include_examples 'scan', /[[:^digit:]]/,          1 => [:nonposixclass, :digit,    '[:^digit:]', 1, 11]
+
+  include_examples 'scan', /[a[.a-b.]c]/,           2 => [:set,    :collation,       '[.a-b.]',    2,  9]
+  include_examples 'scan', /[a[=e=]c]/,             2 => [:set,    :equivalent,      '[=e=]',      2,  7]
+
+  include_examples 'scan', /[a-d&&g-h]/,            4 => [:set,    :intersection,    '&&',         4, 6]
+  include_examples 'scan', /[a&&]/,                 2 => [:set,    :intersection,    '&&',         2, 4]
+  include_examples 'scan', /[&&z]/,                 1 => [:set,    :intersection,    '&&',         1, 3]
+
+  include_examples 'scan', /[a\p{digit}c]/,         2 => [:property,    :digit,      '\p{digit}',  2, 11]
+  include_examples 'scan', /[a\P{digit}c]/,         2 => [:nonproperty, :digit,      '\P{digit}',  2, 11]
+  include_examples 'scan', /[a\p{^digit}c]/,        2 => [:nonproperty, :digit,      '\p{^digit}', 2, 12]
+  include_examples 'scan', /[a\P{^digit}c]/,        2 => [:property,    :digit,      '\P{^digit}', 2, 12]
+
+  include_examples 'scan', /[a\p{ALPHA}c]/,         2 => [:property,    :alpha,      '\p{ALPHA}',  2, 11]
+  include_examples 'scan', /[a\p{P}c]/,             2 => [:property,    :punctuation,'\p{P}',      2, 7]
+  include_examples 'scan', /[a\p{P}\P{P}c]/,        3 => [:nonproperty, :punctuation,'\P{P}',      7, 12]
+
+  include_examples 'scan', /[\x20-\x27]/,
+    1 => [:escape, :hex,             '\x20',       1, 5],
+    2 => [:set,    :range,           '-',          5, 6],
+    3 => [:escape, :hex,             '\x27',       6, 10]
+
+  include_examples 'scan', /[a-w&&[^c-g]z]/,
+    5 => [:set,    :open,            '[',          6, 7],
+    6 => [:set,    :negate,          '^',          7, 8],
+    8 => [:set,    :range,           '-',          9, 10],
+    10=> [:set,    :close,           ']',          11, 12]
+
+  specify('set literal encoding') do
+    text = RS.scan('[a]')[1][2].to_s
+    expect(text).to eq 'a'
+    expect(text.encoding.to_s).to eq 'UTF-8'
+
+    text = RS.scan("[\u{1F632}]")[1][2].to_s
+    expect(text).to eq "\u{1F632}"
+    expect(text.encoding.to_s).to eq 'UTF-8'
+  end
+end

data/vendor/bundle/ruby/2.6.0/gems/regexp_parser-1.8.0/spec/scanner/types_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+RSpec.describe('Type scanning') do
+  include_examples 'scan', 'a\\dc', 1 => [:type, :digit,     '\\d', 1, 3]
+  include_examples 'scan', 'a\\Dc', 1 => [:type, :nondigit,  '\\D', 1, 3]
+  include_examples 'scan', 'a\\hc', 1 => [:type, :hex,       '\\h', 1, 3]
+  include_examples 'scan', 'a\\Hc', 1 => [:type, :nonhex,    '\\H', 1, 3]
+  include_examples 'scan', 'a\\sc', 1 => [:type, :space,     '\\s', 1, 3]
+  include_examples 'scan', 'a\\Sc', 1 => [:type, :nonspace,  '\\S', 1, 3]
+  include_examples 'scan', 'a\\wc', 1 => [:type, :word,      '\\w', 1, 3]
+  include_examples 'scan', 'a\\Wc', 1 => [:type, :nonword,   '\\W', 1, 3]
+  include_examples 'scan', 'a\\Rc', 1 => [:type, :linebreak, '\\R', 1, 3]
+  include_examples 'scan', 'a\\Xc', 1 => [:type, :xgrapheme, '\\X', 1, 3]
+end

data/vendor/bundle/ruby/2.6.0/gems/regexp_parser-1.8.0/spec/spec_helper.rb

@@ -0,0 +1,15 @@
+require 'regexp_parser'
+require 'regexp_property_values'
+require_relative 'support/shared_examples'
+
+RS = Regexp::Scanner
+RL = Regexp::Lexer
+RP = Regexp::Parser
+RE = Regexp::Expression
+T = Regexp::Syntax::Token
+
+include Regexp::Expression
+
+def ruby_version_at_least(version)
+  Gem::Version.new(RUBY_VERSION.dup) >= Gem::Version.new(version)
+end

data/vendor/bundle/ruby/2.6.0/gems/regexp_parser-1.8.0/spec/support/runner.rb

@@ -0,0 +1,42 @@
+require 'pathname'
+require 'rspec'
+
+module RegexpParserSpec
+  class Runner
+    def initialize(arguments, warning_whitelist)
+      @arguments = arguments
+      @warning_whitelist = warning_whitelist
+    end
+
+    def run
+      spec_status = nil
+
+      Warning::Filter.new(warning_whitelist).assert_expected_warnings_only do
+        setup
+        spec_status = run_rspec
+      end
+
+      spec_status
+    end
+
+    private
+
+    def setup
+      $VERBOSE = true
+
+      spec_files.each(&method(:require))
+    end
+
+    def run_rspec
+      RSpec::Core::Runner.run([])
+    end
+
+    def spec_files
+      arguments
+        .map { |path| Pathname.new(path).expand_path.freeze }
+        .select(&:file?)
+    end
+
+    attr_reader :arguments, :warning_whitelist
+  end
+end

data/vendor/bundle/ruby/2.6.0/gems/regexp_parser-1.8.0/spec/support/shared_examples.rb

@@ -0,0 +1,77 @@
+RSpec.shared_examples 'syntax' do |klass, opts|
+  opts[:implements].each do |type, tokens|
+    tokens.each do |token|
+      it("implements #{token} #{type}") do
+        expect(klass.implements?(type, token)).to be true
+      end
+    end
+  end
+
+  opts[:excludes] && opts[:excludes].each do |type, tokens|
+    tokens.each do |token|
+      it("does not implement #{token} #{type}") do
+        expect(klass.implements?(type, token)).to be false
+      end
+    end
+  end
+end
+
+RSpec.shared_examples 'scan' do |pattern, checks|
+  context "given the pattern #{pattern}" do
+    before(:all) { @tokens = Regexp::Scanner.scan(pattern) }
+
+    checks.each do |index, (type, token, text, ts, te)|
+      it "scans token #{index} as #{token} #{type} at #{ts}..#{te}" do
+        result = @tokens.at(index)
+
+        expect(result[0]).to eq type
+        expect(result[1]).to eq token
+        expect(result[2]).to eq text
+        expect(result[3]).to eq ts
+        expect(result[4]).to eq te
+      end
+    end
+  end
+end
+
+RSpec.shared_examples 'lex' do |pattern, checks|
+  context "given the pattern #{pattern}" do
+    before(:all) { @tokens = Regexp::Lexer.lex(pattern) }
+
+    checks.each do |index, (type, token, text, ts, te, lvl, set_lvl, cond_lvl)|
+      it "lexes token #{index} as #{token} #{type} at #{lvl}, #{set_lvl}, #{cond_lvl}" do
+        struct = @tokens.at(index)
+
+        expect(struct.type).to eq type
+        expect(struct.token).to eq token
+        expect(struct.text).to eq text
+        expect(struct.ts).to eq ts
+        expect(struct.te).to eq te
+        expect(struct.level).to eq lvl
+        expect(struct.set_level).to eq set_lvl
+        expect(struct.conditional_level).to eq cond_lvl
+      end
+    end
+  end
+end
+
+RSpec.shared_examples 'parse' do |pattern, checks|
+  context "given the pattern #{pattern}" do
+    before(:all) { @root = Regexp::Parser.parse(pattern, '*') }
+
+    checks.each do |path, (type, token, klass, attributes)|
+      it "parses expression at #{path} as #{klass}" do
+        exp = @root.dig(*path)
+
+        expect(exp).to be_instance_of(klass)
+        expect(exp.type).to eq type
+        expect(exp.token).to eq token
+
+        attributes && attributes.each do |method, value|
+          expect(exp.send(method)).to eq(value),
+            "expected expression at #{path} to have #{method} #{value}"
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.6.0/gems/regexp_parser-1.8.0/spec/support/warning_extractor.rb

@@ -0,0 +1,60 @@
+require 'set'
+require 'delegate'
+
+module RegexpParserSpec
+  class Warning
+    class UnexpectedWarnings < StandardError
+      MSG = 'Unexpected warnings: %s'.freeze
+
+      def initialize(warnings)
+        super(MSG % warnings.join("\n"))
+      end
+    end
+
+    class Filter
+      def initialize(whitelist)
+        @whitelist = whitelist
+      end
+
+      def assert_expected_warnings_only
+        original = $stderr
+        $stderr  = Extractor.new(original, @whitelist)
+
+        yield
+
+        assert_no_warnings($stderr.warnings)
+      ensure
+        $stderr = original
+      end
+
+      private
+
+      def assert_no_warnings(warnings)
+        raise UnexpectedWarnings, warnings.to_a if warnings.any?
+      end
+    end
+
+    class Extractor < DelegateClass(IO)
+      PATTERN = /\A(?:.+):(?:\d+): warning: (?:.+)\n\z/
+
+      def initialize(io, whitelist)
+        @whitelist = whitelist
+        @warnings  = Set.new
+        super(io)
+      end
+
+      def write(message)
+        return super if PATTERN !~ message
+
+        warning = message.chomp
+        @warnings << warning if @whitelist.none?(&warning.method(:include?))
+
+        self
+      end
+
+      def warnings
+        @warnings.dup.freeze
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.6.0/gems/regexp_parser-1.8.0/spec/syntax/syntax_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+
+RSpec.describe(Regexp::Syntax) do
+  specify('unknown name') do
+    expect { Regexp::Syntax.new('ruby/1.0') }.to raise_error(Regexp::Syntax::UnknownSyntaxNameError)
+  end
+
+  specify('new') do
+    expect(Regexp::Syntax.new('ruby/1.9.3')).to be_instance_of(Regexp::Syntax::V1_9_3)
+  end
+
+  specify('new any') do
+    expect(Regexp::Syntax.new('any')).to be_instance_of(Regexp::Syntax::Any)
+    expect(Regexp::Syntax.new('*')).to be_instance_of(Regexp::Syntax::Any)
+  end
+
+  specify('not implemented') do
+    expect { RP.parse('\\p{alpha}', 'ruby/1.8') }.to raise_error(Regexp::Syntax::NotImplementedError)
+  end
+
+  specify('supported?') do
+    expect(Regexp::Syntax.supported?('ruby/1.1.1')).to be false
+    expect(Regexp::Syntax.supported?('ruby/2.4.3')).to be true
+    expect(Regexp::Syntax.supported?('ruby/2.5')).to be true
+  end
+
+  specify('invalid version') do
+    expect { Regexp::Syntax.version_class('2.0.0') }.to raise_error(Regexp::Syntax::InvalidVersionNameError)
+
+    expect { Regexp::Syntax.version_class('ruby/20') }.to raise_error(Regexp::Syntax::InvalidVersionNameError)
+  end
+
+  specify('version class tiny version') do
+    expect(Regexp::Syntax.version_class('ruby/1.9.3')).to eq Regexp::Syntax::V1_9_3
+
+    expect(Regexp::Syntax.version_class('ruby/2.3.1')).to eq Regexp::Syntax::V2_3_1
+  end
+
+  specify('version class minor version') do
+    expect(Regexp::Syntax.version_class('ruby/1.9')).to eq Regexp::Syntax::V1_9
+
+    expect(Regexp::Syntax.version_class('ruby/2.3')).to eq Regexp::Syntax::V2_3
+  end
+
+  specify('raises for unknown constant lookups') do
+    expect { Regexp::Syntax::V1 }.to raise_error(/V1/)
+  end
+end

data/vendor/bundle/ruby/2.6.0/gems/regexp_parser-1.8.0/spec/syntax/syntax_token_map_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+RSpec.describe(Regexp::Syntax::Token::Map) do
+  let(:map) { Regexp::Syntax::Token::Map }
+
+  specify('is complete') do
+    latest_syntax = Regexp::Syntax.new('ruby/2.9')
+
+    latest_syntax.features.each do |type, tokens|
+      tokens.each { |token| expect(map[type]).to include(token) }
+    end
+  end
+
+  specify('contains no duplicate type/token combinations') do
+    combinations = map.flat_map do |type, tokens|
+      tokens.map { |token| "#{type} #{token}" }
+    end
+
+    non_uniq = combinations.group_by { |str| str }.select { |_, v| v.count > 1 }
+
+    expect(non_uniq.keys).to be_empty
+  end
+end

data/vendor/bundle/ruby/2.6.0/gems/regexp_parser-1.8.0/spec/syntax/versions/1.8.6_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+RSpec.describe(Regexp::Syntax::V1_8_6) do
+  include_examples 'syntax', Regexp::Syntax.new('ruby/1.8.6'),
+  implements: {
+    assertion: T::Assertion::Lookahead,
+    backref: [:number],
+    escape: T::Escape::Basic + T::Escape::ASCII + T::Escape::Meta + T::Escape::Control,
+    group: T::Group::V1_8_6,
+    quantifier: T::Quantifier::Greedy + T::Quantifier::Reluctant + T::Quantifier::Interval + T::Quantifier::IntervalReluctant
+  },
+  excludes: {
+    assertion: T::Assertion::Lookbehind,
+    backref: T::Backreference::All - [:number] + T::SubexpressionCall::All,
+    quantifier: T::Quantifier::Possessive
+  }
+end

data/vendor/bundle/ruby/2.6.0/gems/regexp_parser-1.8.0/spec/syntax/versions/1.9.1_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+
+RSpec.describe(Regexp::Syntax::V1_9_1) do
+  include_examples 'syntax', Regexp::Syntax.new('ruby/1.9.1'),
+  implements: {
+    escape: T::Escape::Hex + T::Escape::Octal + T::Escape::Unicode,
+    type: T::CharacterType::Hex,
+    quantifier: T::Quantifier::Greedy + T::Quantifier::Reluctant + T::Quantifier::Possessive
+  }
+end

data/vendor/bundle/ruby/2.6.0/gems/regexp_parser-1.8.0/spec/syntax/versions/1.9.3_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+RSpec.describe(Regexp::Syntax::V1_9_3) do
+  include_examples 'syntax', Regexp::Syntax.new('ruby/1.9.3'),
+  implements: {
+    property: T::UnicodeProperty::Script_V1_9_3 + T::UnicodeProperty::Age_V1_9_3,
+    nonproperty: T::UnicodeProperty::Script_V1_9_3 + T::UnicodeProperty::Age_V1_9_3
+  }
+end

data/vendor/bundle/ruby/2.6.0/gems/regexp_parser-1.8.0/spec/syntax/versions/2.0.0_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+RSpec.describe(Regexp::Syntax::V2_0_0) do
+  include_examples 'syntax', Regexp::Syntax.new('ruby/2.0.0'),
+  implements: {
+    property: T::UnicodeProperty::Age_V2_0_0,
+    nonproperty: T::UnicodeProperty::Age_V2_0_0
+  },
+  excludes: {
+    property: [:newline],
+    nonproperty: [:newline]
+  }
+end

data/vendor/bundle/ruby/2.6.0/gems/regexp_parser-1.8.0/spec/syntax/versions/2.2.0_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+RSpec.describe(Regexp::Syntax::V2_2_0) do
+  include_examples 'syntax', Regexp::Syntax.new('ruby/2.2.0'),
+  implements: {
+    property: T::UnicodeProperty::Script_V2_2_0 + T::UnicodeProperty::Age_V2_2_0,
+    nonproperty: T::UnicodeProperty::Script_V2_2_0 + T::UnicodeProperty::Age_V2_2_0
+  }
+end

data/vendor/bundle/ruby/2.6.0/gems/regexp_parser-1.8.0/spec/syntax/versions/aliases_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+RSpec.describe(Regexp::Syntax) do
+  RSpec.shared_examples 'syntax alias' do |string, klass|
+    it "aliases #{string} to #{klass}" do
+      syntax = Regexp::Syntax.new(string)
+      expect(syntax).to be_a klass
+    end
+  end
+
+  include_examples 'syntax alias', 'ruby/1.8.6',  Regexp::Syntax::V1_8_6
+  include_examples 'syntax alias', 'ruby/1.8',    Regexp::Syntax::V1_8_6
+  include_examples 'syntax alias', 'ruby/1.9.1',  Regexp::Syntax::V1_9_1
+  include_examples 'syntax alias', 'ruby/1.9',    Regexp::Syntax::V1_9_3
+  include_examples 'syntax alias', 'ruby/2.0.0',  Regexp::Syntax::V1_9
+  include_examples 'syntax alias', 'ruby/2.0',    Regexp::Syntax::V2_0_0
+  include_examples 'syntax alias', 'ruby/2.1',    Regexp::Syntax::V2_0_0
+  include_examples 'syntax alias', 'ruby/2.2.0',  Regexp::Syntax::V2_0_0
+  include_examples 'syntax alias', 'ruby/2.2.10', Regexp::Syntax::V2_0_0
+  include_examples 'syntax alias', 'ruby/2.2',    Regexp::Syntax::V2_0_0
+  include_examples 'syntax alias', 'ruby/2.3.0',  Regexp::Syntax::V2_3_0
+  include_examples 'syntax alias', 'ruby/2.3',    Regexp::Syntax::V2_3_0
+  include_examples 'syntax alias', 'ruby/2.4.0',  Regexp::Syntax::V2_4_0
+  include_examples 'syntax alias', 'ruby/2.4.1',  Regexp::Syntax::V2_4_1
+  include_examples 'syntax alias', 'ruby/2.5.0',  Regexp::Syntax::V2_4_1
+  include_examples 'syntax alias', 'ruby/2.5',    Regexp::Syntax::V2_5_0
+  include_examples 'syntax alias', 'ruby/2.6.0',  Regexp::Syntax::V2_5_0
+  include_examples 'syntax alias', 'ruby/2.6.2',  Regexp::Syntax::V2_6_2
+  include_examples 'syntax alias', 'ruby/2.6.3',  Regexp::Syntax::V2_6_3
+  include_examples 'syntax alias', 'ruby/2.6',    Regexp::Syntax::V2_6_3
+
+  specify('future alias warning') do
+    expect { Regexp::Syntax.new('ruby/5.0') }
+      .to output(/This library .* but you are running .* \(feature set of .*\)/)
+      .to_stderr
+  end
+end

data/vendor/bundle/ruby/2.6.0/gems/regexp_parser-1.8.0/spec/token/token_spec.rb

@@ -0,0 +1,85 @@
+require 'spec_helper'
+
+RSpec.describe(Regexp::Token) do
+  specify('#offset') do
+    regexp = /ab?cd/
+    tokens = RL.lex(regexp)
+
+    expect(tokens[1].text).to eq 'b'
+    expect(tokens[1].offset).to eq [1, 2]
+
+    expect(tokens[2].text).to eq '?'
+    expect(tokens[2].offset).to eq [2, 3]
+
+    expect(tokens[3].text).to eq 'cd'
+    expect(tokens[3].offset).to eq [3, 5]
+  end
+
+  specify('#length') do
+    regexp = /abc?def/
+    tokens = RL.lex(regexp)
+
+    expect(tokens[0].text).to eq 'ab'
+    expect(tokens[0].length).to eq 2
+
+    expect(tokens[1].text).to eq 'c'
+    expect(tokens[1].length).to eq 1
+
+    expect(tokens[2].text).to eq '?'
+    expect(tokens[2].length).to eq 1
+
+    expect(tokens[3].text).to eq 'def'
+    expect(tokens[3].length).to eq 3
+  end
+
+  specify('#to_h') do
+    regexp = /abc?def/
+    tokens = RL.lex(regexp)
+
+    expect(tokens[0].text).to eq 'ab'
+    expect(tokens[0].to_h).to eq type: :literal, token: :literal, text: 'ab', ts: 0, te: 2, level: 0, set_level: 0, conditional_level: 0
+
+    expect(tokens[2].text).to eq '?'
+    expect(tokens[2].to_h).to eq type: :quantifier, token: :zero_or_one, text: '?', ts: 3, te: 4, level: 0, set_level: 0, conditional_level: 0
+  end
+
+  specify('#next') do
+    regexp = /a+b?c*d{2,3}/
+    tokens = RL.lex(regexp)
+
+    a = tokens.first
+    expect(a.text).to eq 'a'
+
+    plus = a.next
+    expect(plus.text).to eq '+'
+
+    b = plus.next
+    expect(b.text).to eq 'b'
+
+    interval = tokens.last
+    expect(interval.text).to eq '{2,3}'
+
+    expect(interval.next).to be_nil
+  end
+
+  specify('#previous') do
+    regexp = /a+b?c*d{2,3}/
+    tokens = RL.lex(regexp)
+
+    interval = tokens.last
+    expect(interval.text).to eq '{2,3}'
+
+    d = interval.previous
+    expect(d.text).to eq 'd'
+
+    star = d.previous
+    expect(star.text).to eq '*'
+
+    c = star.previous
+    expect(c.text).to eq 'c'
+
+    a = tokens.first
+    expect(a.text).to eq 'a'
+    expect(a.previous).to be_nil
+  end
+end

data/vendor/bundle/ruby/2.6.0/gems/rexml-3.2.4/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+Gemfile.lock

data/vendor/bundle/ruby/2.6.0/gems/rexml-3.2.4/.travis.yml

@@ -0,0 +1,24 @@
+notifications:
+  webhooks:
+    - https://webhook.commit-email.info/
+matrix:
+  include:
+    - name: "2.3"
+      rvm: 2.3
+    - name: "2.4"
+      rvm: 2.4.5
+    - name: "2.5"
+      rvm: 2.5.2
+    - name: "2.6"
+      rvm: 2.6.0-rc2
+    - name: "trunk"
+      rvm: ruby-head
+    - name: "gem"
+      rvm: 2.6
+      install:
+        - rake install
+      script:
+        - mkdir -p tmp
+        - cd tmp
+        - cp -a ../test/ ./
+        - ../run-test.rb

data/vendor/bundle/ruby/2.6.0/gems/rexml-3.2.4/Gemfile

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in rexml.gemspec
+gemspec

data/vendor/bundle/ruby/2.6.0/gems/rexml-3.2.4/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (C) 1993-2013 Yukihiro Matsumoto. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+1. Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+2. Redistributions in binary form must reproduce the above copyright
+notice, this list of conditions and the following disclaimer in the
+documentation and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGE.