regexp_parser 2.0.2 → 2.2.0

data/spec/scanner/refcalls_spec.rb

@@ -5,9 +5,19 @@ RSpec.describe('RefCall scanning') do
   include_examples 'scan', '(abc)\1' ,          3 => [:backref, :number,                  '\1',         5, 7]
 
   # Group back-references, named, numbered, and relative
+  #
+  # NOTE: only \g supports forward-looking references using '+', e.g. \g<+1>
+  # refers to the next group, but \k<+1> refers to a group named '+1'.
+  # Inversely, only \k supports addition or substraction of a recursion level.
+  # E.g. \k<x+0> refers to a group named 'x' at the current recursion level,
+  # but \g<x+0> refers to a a group named 'x+0'.
+  #
   include_examples 'scan', '(?<X>abc)\k<X>',    3 => [:backref, :name_ref_ab,             '\k<X>',      9, 14]
   include_examples 'scan', "(?<X>abc)\\k'X'",   3 => [:backref, :name_ref_sq,             "\\k'X'",     9, 14]
 
+  include_examples 'scan', '(?<+1>abc)\k<+1>',  3 => [:backref, :name_ref_ab,             '\k<+1>',    10, 16]
+  include_examples 'scan', "(?<+1>abc)\\k'+1'", 3 => [:backref, :name_ref_sq,             "\\k'+1'",   10, 16]
+
   include_examples 'scan', '(abc)\k<1>',        3 => [:backref, :number_ref_ab,           '\k<1>',      5, 10]
   include_examples 'scan', "(abc)\\k'1'",       3 => [:backref, :number_ref_sq,           "\\k'1'",     5, 10]
 
@@ -18,9 +28,15 @@ RSpec.describe('RefCall scanning') do
   include_examples 'scan', '(?<X>abc)\g<X>',    3 => [:backref, :name_call_ab,            '\g<X>',      9, 14]
   include_examples 'scan', "(?<X>abc)\\g'X'",   3 => [:backref, :name_call_sq,            "\\g'X'",     9, 14]
 
+  include_examples 'scan', '(?<X>abc)\g<X-1>',  3 => [:backref, :name_call_ab,            '\g<X-1>',    9, 16]
+  include_examples 'scan', "(?<X>abc)\\g'X-1'", 3 => [:backref, :name_call_sq,            "\\g'X-1'",   9, 16]
+
   include_examples 'scan', '(abc)\g<1>',        3 => [:backref, :number_call_ab,          '\g<1>',      5, 10]
   include_examples 'scan', "(abc)\\g'1'",       3 => [:backref, :number_call_sq,          "\\g'1'",     5, 10]
 
+  include_examples 'scan', 'a(b|\g<0>)',        4 => [:backref, :number_call_ab,          '\g<0>',      4, 9]
+  include_examples 'scan', "a(b|\\g'0')",       4 => [:backref, :number_call_sq,          "\\g'0'",     4, 9]
+
   include_examples 'scan', '(abc)\g<-1>',       3 => [:backref, :number_rel_call_ab,      '\g<-1>',     5, 11]
   include_examples 'scan', "(abc)\\g'-1'",      3 => [:backref, :number_rel_call_sq,      "\\g'-1'",    5, 11]
 
@@ -33,4 +49,7 @@ RSpec.describe('RefCall scanning') do
 
   include_examples 'scan', '(abc)\k<1-0>',      3 => [:backref, :number_recursion_ref_ab, '\k<1-0>',    5, 12]
   include_examples 'scan', "(abc)\\k'1-0'",     3 => [:backref, :number_recursion_ref_sq, "\\k'1-0'",   5, 12]
+
+  include_examples 'scan', '(abc)\k<+1-0>',     3 => [:backref, :name_recursion_ref_ab,   '\k<+1-0>',   5, 13]
+  include_examples 'scan', "(abc)\\k'+1-0'",    3 => [:backref, :name_recursion_ref_sq,   "\\k'+1-0'",  5, 13]
 end

data/spec/scanner/sets_spec.rb

@@ -6,8 +6,18 @@ RSpec.describe('Set scanning') do
   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', /[^d]/,                  2 => [:literal, :literal,        'd',          2, 3]
+
+  include_examples 'scan', /[\b]/,                  1 => [:escape, :backspace,       '\b',         1, 3]
+  include_examples 'scan', /[A\bX]/,                2 => [:escape, :backspace,       '\b',         2, 4]
+
+  include_examples 'scan', /[\a]/,                  1 => [:escape, :bell,            '\a',         1, 3]
+  include_examples 'scan', /[\e]/,                  1 => [:escape, :escape,          '\e',         1, 3]
+  include_examples 'scan', /[\f]/,                  1 => [:escape, :form_feed,       '\f',         1, 3]
+  include_examples 'scan', /[\n]/,                  1 => [:escape, :newline,         '\n',         1, 3]
+  include_examples 'scan', /[\r]/,                  1 => [:escape, :carriage,        '\r',         1, 3]
+  include_examples 'scan', /[\t]/,                  1 => [:escape, :tab,             '\t',         1, 3]
+  include_examples 'scan', /[\v]/,                  1 => [:escape, :vertical_tab,    '\v',         1, 3]
 
   include_examples 'scan', /[.]/,                   1 => [:literal, :literal,        '.',          1, 2]
   include_examples 'scan', /[?]/,                   1 => [:literal, :literal,        '?',          1, 2]
@@ -18,22 +28,36 @@ RSpec.describe('Set scanning') do
   include_examples 'scan', /[<]/,                   1 => [:literal, :literal,        '<',          1, 2]
   include_examples 'scan', /[>]/,                   1 => [:literal, :literal,        '>',          1, 2]
 
-  include_examples 'scan', /[\x20]/,                1 => [:escape, :hex,             '\x20',       1, 5]
-
-  include_examples 'scan', '[\.]',                  1 => [:escape, :dot,             '\.',         1, 3]
+  include_examples 'scan', '[\\\\]',                1 => [:escape, :backslash,       '\\\\',       1, 3]
+  include_examples 'scan', '[\u0040]',              1 => [:escape, :codepoint,       '\u0040',     1, 7]
+  include_examples 'scan', '[\u{40}]',              1 => [:escape, :codepoint_list,  '\u{40}',     1, 7]
+  include_examples 'scan', '[\c2]',                 1 => [:escape, :control,         '\c2',        1, 4]
+  include_examples 'scan', '[\C-C]',                1 => [:escape, :control,         '\C-C',       1, 5]
+  include_examples 'scan', '[\x20]',                1 => [:escape, :hex,             '\x20',       1, 5]
+  include_examples 'scan', '[\M-Z]',                1 => [:escape, :meta_sequence,   '\M-Z',       1, 5]
+  include_examples 'scan', '[\M-\C-X]',             1 => [:escape, :meta_sequence,   '\M-\C-X',    1, 8]
+  include_examples 'scan', '[\\[]',                 1 => [:escape, :set_open,        '\[',         1, 3]
+  include_examples 'scan', '[\\]]',                 1 => [:escape, :set_close,       '\]',         1, 3]
+  include_examples 'scan', '[a\-]',                 2 => [:escape, :literal,         '\-',         2, 4]
+  include_examples 'scan', '[\-c]',                 1 => [:escape, :literal,         '\-',         1, 3]
+  include_examples 'scan', '[\.]',                  1 => [:escape, :literal,         '\.',         1, 3]
+  include_examples 'scan', '[\?]',                  1 => [:escape, :literal,         '\?',         1, 3]
+  include_examples 'scan', '[\*]',                  1 => [:escape, :literal,         '\*',         1, 3]
+  include_examples 'scan', '[\+]',                  1 => [:escape, :literal,         '\+',         1, 3]
+  include_examples 'scan', '[\|]',                  1 => [:escape, :literal,         '\|',         1, 3]
+  include_examples 'scan', '[\{]',                  1 => [:escape, :literal,         '\{',         1, 3]
+  include_examples 'scan', '[\}]',                  1 => [:escape, :literal,         '\}',         1, 3]
+  include_examples 'scan', '[\(]',                  1 => [:escape, :literal,         '\(',         1, 3]
+  include_examples 'scan', '[\)]',                  1 => [:escape, :literal,         '\)',         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]
@@ -54,40 +78,59 @@ RSpec.describe('Set scanning') do
   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-bd-f]/,              2 => [:set,     :range,          '-',          2, 3]
+  include_examples 'scan', /[a-cd-f]/,              5 => [:set,     :range,          '-',          5, 6]
+  # this is a buggy range, it matches only `c`, but not `a`, `b` or `-`
+  include_examples 'scan', /[a-[c]]/,               2 => [:set,     :range,          '-',          2, 3]
+  # these are not ranges, they match `a`, `c` and `-` (or non-`-` if negated)
+  include_examples 'scan', /[[a]-[c]]/,             4 => [:literal, :literal,        '-',          4, 5]
+  include_examples 'scan', /[[a]-c]/,               4 => [:literal, :literal,        '-',          4, 5]
+  include_examples 'scan', /[^-c]/,                 2 => [:literal, :literal,        '-',          2, 3]
 
   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', /[&&]/,                  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{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', '[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]/,
+  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]/,
+  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]
 
+  # Collations/collating sequences and character equivalents are not enabled
+  # in Ruby at the moment. If they ever are, enable them in the scanner,
+  # add them to a new syntax version, and handle them in the parser. Until then,
+  # expect them to be scanned as regular subsets containing literals.
+  # 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[.a-b.]c]',
+    2 => [:set,     :open,           '[',          2,  3],
+    3 => [:literal, :literal,        '.',          3,  4],
+    4 => [:literal, :literal,        'a',          4,  5]
+  include_examples 'scan', '[a[=e=]c]',
+    2 => [:set,     :open,           '[',          2,  3],
+    3 => [:literal, :literal,        '=',          3,  4],
+    4 => [:literal, :literal,        'e',          4,  5]
+
   # multi-byte characters should not affect indices
   include_examples 'scan', /[れます]/,
     0 => [:set,     :open,           '[',          0, 1],

data/spec/spec_helper.rb

@@ -1,8 +1,13 @@
+$VERBOSE = true
+
 require 'ice_nine'
-require 'regexp_parser'
 require 'regexp_property_values'
+require_relative 'support/capturing_stderr'
 require_relative 'support/shared_examples'
 
+req_warn = capturing_stderr { require('regexp_parser') || fail('pre-required') }
+req_warn.empty? || fail("requiring parser generated warnings:\n#{req_warn}")
+
 RS = Regexp::Scanner
 RL = Regexp::Lexer
 RP = Regexp::Parser
@@ -14,3 +19,10 @@ include Regexp::Expression
 def ruby_version_at_least(version)
   Gem::Version.new(RUBY_VERSION.dup) >= Gem::Version.new(version)
 end
+
+RSpec.configure do |config|
+  config.around(:example) do |example|
+    # treat unexpected warnings as failures
+    expect { example.run }.not_to output.to_stderr
+  end
+end

data/spec/support/capturing_stderr.rb

@@ -0,0 +1,9 @@
+require 'stringio'
+
+def capturing_stderr(&block)
+  old_stderr, $stderr = $stderr, StringIO.new
+  block.call
+  $stderr.string
+ensure
+  $stderr = old_stderr
+end

data/spec/syntax/versions/1.8.6_spec.rb

@@ -4,14 +4,14 @@ 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],
+    backref: T::Backreference::Plain,
     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,
+    backref: T::Backreference::All - T::Backreference::Plain + T::SubexpressionCall::All,
     quantifier: T::Quantifier::Possessive
   }
 end

data/spec/syntax/versions/2.0.0_spec.rb

@@ -7,7 +7,7 @@ RSpec.describe(Regexp::Syntax::V2_0_0) do
     nonproperty: T::UnicodeProperty::Age_V2_0_0
   },
   excludes: {
-    property: [:newline],
-    nonproperty: [:newline]
+    property: %i[newline],
+    nonproperty: %i[newline]
   }
 end

data/spec/syntax/versions/aliases_spec.rb

@@ -28,6 +28,7 @@ RSpec.describe(Regexp::Syntax) do
   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
+  include_examples 'syntax alias', 'ruby/3.1',    Regexp::Syntax::V3_1_0
 
   specify('future alias warning') do
     expect { Regexp::Syntax.new('ruby/5.0') }

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: regexp_parser
 version: !ruby/object:Gem::Version
-  version: 2.0.2
+  version: 2.2.0
 platform: ruby
 authors:
 - Ammar Ali
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-12-25 00:00:00.000000000 Z
+date: 2021-12-04 00:00:00.000000000 Z
 dependencies: []
 description: A library for tokenizing, lexing, and parsing Ruby regular expressions.
 email:
@@ -23,12 +23,17 @@ files:
 - README.md
 - Rakefile
 - lib/regexp_parser.rb
+- lib/regexp_parser/error.rb
 - lib/regexp_parser/expression.rb
+- lib/regexp_parser/expression/base.rb
 - lib/regexp_parser/expression/classes/alternation.rb
 - lib/regexp_parser/expression/classes/anchor.rb
-- lib/regexp_parser/expression/classes/backref.rb
+- lib/regexp_parser/expression/classes/backreference.rb
+- lib/regexp_parser/expression/classes/character_set.rb
+- lib/regexp_parser/expression/classes/character_set/intersection.rb
+- lib/regexp_parser/expression/classes/character_set/range.rb
 - lib/regexp_parser/expression/classes/conditional.rb
-- lib/regexp_parser/expression/classes/escape.rb
+- lib/regexp_parser/expression/classes/escape_sequence.rb
 - lib/regexp_parser/expression/classes/free_space.rb
 - lib/regexp_parser/expression/classes/group.rb
 - lib/regexp_parser/expression/classes/keep.rb
@@ -36,9 +41,6 @@ files:
 - lib/regexp_parser/expression/classes/posix_class.rb
 - lib/regexp_parser/expression/classes/property.rb
 - lib/regexp_parser/expression/classes/root.rb
-- lib/regexp_parser/expression/classes/set.rb
-- lib/regexp_parser/expression/classes/set/intersection.rb
-- lib/regexp_parser/expression/classes/set/range.rb
 - lib/regexp_parser/expression/classes/type.rb
 - lib/regexp_parser/expression/methods/match.rb
 - lib/regexp_parser/expression/methods/match_length.rb
@@ -61,20 +63,20 @@ files:
 - lib/regexp_parser/syntax.rb
 - lib/regexp_parser/syntax/any.rb
 - lib/regexp_parser/syntax/base.rb
-- lib/regexp_parser/syntax/tokens.rb
-- lib/regexp_parser/syntax/tokens/anchor.rb
-- lib/regexp_parser/syntax/tokens/assertion.rb
-- lib/regexp_parser/syntax/tokens/backref.rb
-- lib/regexp_parser/syntax/tokens/character_set.rb
-- lib/regexp_parser/syntax/tokens/character_type.rb
-- lib/regexp_parser/syntax/tokens/conditional.rb
-- lib/regexp_parser/syntax/tokens/escape.rb
-- lib/regexp_parser/syntax/tokens/group.rb
-- lib/regexp_parser/syntax/tokens/keep.rb
-- lib/regexp_parser/syntax/tokens/meta.rb
-- lib/regexp_parser/syntax/tokens/posix_class.rb
-- lib/regexp_parser/syntax/tokens/quantifier.rb
-- lib/regexp_parser/syntax/tokens/unicode_property.rb
+- lib/regexp_parser/syntax/token.rb
+- lib/regexp_parser/syntax/token/anchor.rb
+- lib/regexp_parser/syntax/token/assertion.rb
+- lib/regexp_parser/syntax/token/backreference.rb
+- lib/regexp_parser/syntax/token/character_set.rb
+- lib/regexp_parser/syntax/token/character_type.rb
+- lib/regexp_parser/syntax/token/conditional.rb
+- lib/regexp_parser/syntax/token/escape.rb
+- lib/regexp_parser/syntax/token/group.rb
+- lib/regexp_parser/syntax/token/keep.rb
+- lib/regexp_parser/syntax/token/meta.rb
+- lib/regexp_parser/syntax/token/posix_class.rb
+- lib/regexp_parser/syntax/token/quantifier.rb
+- lib/regexp_parser/syntax/token/unicode_property.rb
 - lib/regexp_parser/syntax/version_lookup.rb
 - lib/regexp_parser/syntax/versions.rb
 - lib/regexp_parser/syntax/versions/1.8.6.rb
@@ -89,6 +91,7 @@ files:
 - lib/regexp_parser/syntax/versions/2.6.0.rb
 - lib/regexp_parser/syntax/versions/2.6.2.rb
 - lib/regexp_parser/syntax/versions/2.6.3.rb
+- lib/regexp_parser/syntax/versions/3.1.0.rb
 - lib/regexp_parser/token.rb
 - lib/regexp_parser/version.rb
 - regexp_parser.gemspec
@@ -149,9 +152,8 @@ files:
 - spec/scanner/sets_spec.rb
 - spec/scanner/types_spec.rb
 - spec/spec_helper.rb
-- spec/support/runner.rb
+- spec/support/capturing_stderr.rb
 - spec/support/shared_examples.rb
-- spec/support/warning_extractor.rb
 - spec/syntax/syntax_spec.rb
 - spec/syntax/syntax_token_map_spec.rb
 - spec/syntax/versions/1.8.6_spec.rb
@@ -183,7 +185,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.0
+rubygems_version: 3.3.0.dev
 signing_key:
 specification_version: 4
 summary: Scanner, lexer, parser for ruby's regular expressions
@@ -245,9 +247,8 @@ test_files:
 - spec/scanner/sets_spec.rb
 - spec/scanner/types_spec.rb
 - spec/spec_helper.rb
-- spec/support/runner.rb
+- spec/support/capturing_stderr.rb
 - spec/support/shared_examples.rb
-- spec/support/warning_extractor.rb
 - spec/syntax/syntax_spec.rb
 - spec/syntax/syntax_token_map_spec.rb
 - spec/syntax/versions/1.8.6_spec.rb

data/lib/regexp_parser/syntax/tokens/anchor.rb

@@ -1,15 +0,0 @@
-module Regexp::Syntax
-  module Token
-    module Anchor
-      Basic       = [:bol, :eol]
-      Extended    = Basic + [:word_boundary, :nonword_boundary]
-      String      = [:bos, :eos, :eos_ob_eol]
-      MatchStart  = [:match_start]
-
-      All = Extended + String + MatchStart
-      Type = :anchor
-    end
-
-    Map[Anchor::Type] = Anchor::All
-  end
-end

data/lib/regexp_parser/syntax/tokens/escape.rb

@@ -1,30 +0,0 @@
-module Regexp::Syntax
-  module Token
-    module Escape
-      Basic = [:backslash, :literal]
-
-      Control = [:control, :meta_sequence]
-
-      ASCII = [:bell, :backspace, :escape, :form_feed, :newline, :carriage,
-               :tab, :vertical_tab]
-
-      Unicode = [:codepoint, :codepoint_list]
-
-      Meta  = [:dot, :alternation,
-               :zero_or_one, :zero_or_more, :one_or_more,
-               :bol, :eol,
-               :group_open, :group_close,
-               :interval_open, :interval_close,
-               :set_open, :set_close]
-
-      Hex   = [:hex]
-
-      Octal = [:octal]
-
-      All   = Basic + Control + ASCII + Unicode + Meta + Hex + Octal
-      Type  = :escape
-    end
-
-    Map[Escape::Type] = Escape::All
-  end
-end

data/lib/regexp_parser/syntax/tokens/quantifier.rb

@@ -1,35 +0,0 @@
-module Regexp::Syntax
-  module Token
-    module Quantifier
-      Greedy    = [
-        :zero_or_one,
-        :zero_or_more,
-        :one_or_more
-      ]
-
-      Reluctant = [
-        :zero_or_one_reluctant,
-        :zero_or_more_reluctant,
-        :one_or_more_reluctant
-      ]
-
-      Possessive  = [
-        :zero_or_one_possessive,
-        :zero_or_more_possessive,
-        :one_or_more_possessive
-      ]
-
-      Interval             = [:interval]
-      IntervalReluctant    = [:interval_reluctant]
-      IntervalPossessive   = [:interval_possessive]
-
-      IntervalAll = Interval + IntervalReluctant +
-                    IntervalPossessive
-
-      All = Greedy + Reluctant + Possessive + IntervalAll
-      Type = :quantifier
-    end
-
-    Map[Quantifier::Type] = Quantifier::All
-  end
-end