regexp_parser 2.1.1 → 2.2.1

data/spec/expression/to_s_spec.rb

@@ -1,108 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe('Expression#to_s') do
-  def parse_frozen(pattern, ruby_version = nil)
-    IceNine.deep_freeze(RP.parse(pattern, *ruby_version))
-  end
-
-  def expect_round_trip(pattern, ruby_version = nil)
-    parsed = parse_frozen(pattern, ruby_version)
-
-    expect(parsed.to_s).to eql(pattern)
-  end
-
-  specify('literal alternation') do
-    expect_round_trip('abcd|ghij|klmn|pqur')
-  end
-
-  specify('quantified alternations') do
-    expect_round_trip('(?:a?[b]+(c){2}|d+[e]*(f)?)|(?:g+[h]?(i){2,3}|j*[k]{3,5}(l)?)')
-  end
-
-  specify('quantified sets') do
-    expect_round_trip('[abc]+|[^def]{3,6}')
-  end
-
-  specify('property sets') do
-    expect_round_trip('[\\a\\b\\p{Lu}\\P{Z}\\c\\d]+', 'ruby/1.9')
-  end
-
-  specify('groups') do
-    expect_round_trip("(a(?>b(?:c(?<n>d(?'N'e)??f)+g)*+h)*i)++", 'ruby/1.9')
-  end
-
-  specify('assertions') do
-    expect_round_trip('(a+(?=b+(?!c+(?<=d+(?<!e+)?f+)?g+)?h+)?i+)?', 'ruby/1.9')
-  end
-
-  specify('comments') do
-    expect_round_trip('(?#start)a(?#middle)b(?#end)')
-  end
-
-  specify('options') do
-    expect_round_trip('(?mix:start)a(?-mix:middle)b(?i-mx:end)')
-  end
-
-  specify('url') do
-    expect_round_trip('(^$)|(^(http|https):\\/\\/[a-z0-9]+([\\-\\.]{1}[a-z0-9]+)*' + '\\.[a-z]{2,5}(([0-9]{1,5})?\\/.*)?$)')
-  end
-
-  specify('multiline source') do
-    multiline = /
-          \A
-          a?      # One letter
-          b{2,5}  # Another one
-          [c-g]+  # A set
-          \z
-        /x
-
-    expect(parse_frozen(multiline).to_s).to eql(multiline.source)
-  end
-
-  specify('multiline #to_s') do
-    multiline = /
-          \A
-          a?      # One letter
-          b{2,5}  # Another one
-          [c-g]+  # A set
-          \z
-        /x
-
-    expect_round_trip(multiline.to_s)
-  end
-
-  # Free spacing expressions that use spaces between quantifiers and their
-  # targets do not produce identical results due to the way quantifiers are
-  # applied to expressions (members, not nodes) and the merging of consecutive
-  # space nodes. This tests that they produce equivalent results.
-  specify('multiline equivalence') do
-    multiline = /
-          \A
-          a   ?             # One letter
-          b {2,5}           # Another one
-          [c-g]  +          # A set
-          \z
-        /x
-
-    str = 'bbbcged'
-    root = parse_frozen(multiline)
-
-    expect(Regexp.new(root.to_s, Regexp::EXTENDED).match(str)[0]).to eql(multiline.match(str)[0])
-  end
-
-  # special case: implicit groups used for chained quantifiers produce no parens
-  specify 'chained quantifiers #to_s' do
-    pattern = /a+{1}{2}/
-    root = parse_frozen(pattern)
-    expect(root.to_s).to eql('a+{1}{2}')
-  end
-
-  # regression test for https://github.com/ammar/regexp_parser/issues/74
-  specify('non-ascii comment') do
-    pattern = '(?x) 😋 # 😋'
-    root = RP.parse(pattern)
-    expect(root.last).to be_a(Regexp::Expression::Comment)
-    expect(root.last.to_s).to eql('# 😋')
-    expect(root.to_s).to eql(pattern)
-  end
-end

data/spec/lexer/all_spec.rb

@@ -1,22 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe(Regexp::Lexer) do
-  specify('lexer returns an array') do
-    expect(RL.lex('abc')).to be_instance_of(Array)
-  end
-
-  specify('lexer returns tokens') do
-    tokens = RL.lex('^abc+[^one]{2,3}\\b\\d\\\\C-C$')
-    expect(tokens).to all(be_a Regexp::Token)
-    expect(tokens.map { |token| token.to_a.length }).to all(eq 8)
-  end
-
-  specify('lexer token count') do
-    tokens = RL.lex(/^(one|two){2,3}([^d\]efm-qz\,\-]*)(ghi)+$/i)
-    expect(tokens.length).to eq 28
-  end
-
-  specify('lexer scan alias') do
-    expect(RL.scan(/a|b|c/)).to eq RL.lex(/a|b|c/)
-  end
-end

data/spec/lexer/conditionals_spec.rb

@@ -1,53 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe('Conditional lexing') do
-  include_examples 'lex', /(?<A>a)(?(<A>)b|c)/,
-    3 => [:conditional, :open,       '(?',     7,  9, 0, 0, 0],
-    4 => [:conditional, :condition,  '(<A>)',  9, 14, 0, 0, 1],
-    6 => [:conditional, :separator,  '|',     15, 16, 0, 0, 1],
-    8 => [:conditional, :close,      ')',     17, 18, 0, 0, 0]
-
-  include_examples 'lex', /((?<A>a)(?<B>(?(<A>)b|((?(<B>)[e-g]|[h-j])))))/,
-     0 => [:group,       :capture,     '(',       0,  1, 0, 0, 0],
-     1 => [:group,       :named,       '(?<A>',   1,  6, 1, 0, 0],
-     5 => [:conditional, :open,        '(?',     13, 15, 2, 0, 0],
-     6 => [:conditional, :condition,   '(<A>)',  15, 20, 2, 0, 1],
-     8 => [:conditional, :separator,   '|',      21, 22, 2, 0, 1],
-    10 => [:conditional, :open,        '(?',     23, 25, 3, 0, 1],
-    11 => [:conditional, :condition,   '(<B>)',  25, 30, 3, 0, 2],
-    12 => [:set,         :open,        '[',      30, 31, 3, 0, 2],
-    13 => [:literal,     :literal,     'e',      31, 32, 3, 1, 2],
-    14 => [:set,         :range,       '-',      32, 33, 3, 1, 2],
-    15 => [:literal,     :literal,     'g',      33, 34, 3, 1, 2],
-    16 => [:set,         :close,       ']',      34, 35, 3, 0, 2],
-    17 => [:conditional, :separator,   '|',      35, 36, 3, 0, 2],
-    23 => [:conditional, :close,       ')',      41, 42, 3, 0, 1],
-    25 => [:conditional, :close,       ')',      43, 44, 2, 0, 0],
-    26 => [:group,       :close,       ')',      44, 45, 1, 0, 0],
-    27 => [:group,       :close,       ')',      45, 46, 0, 0, 0]
-
-  include_examples 'lex', /(a(b(c)))(?(1)(?(2)(?(3)d|e))|(?(3)(?(2)f|g)|(?(1)f|g)))/,
-     9 => [:conditional, :open,       '(?',    9, 11, 0, 0, 0],
-    10 => [:conditional, :condition,  '(1)',  11, 14, 0, 0, 1],
-    11 => [:conditional, :open,       '(?',   14, 16, 0, 0, 1],
-    12 => [:conditional, :condition,  '(2)',  16, 19, 0, 0, 2],
-    13 => [:conditional, :open,       '(?',   19, 21, 0, 0, 2],
-    14 => [:conditional, :condition,  '(3)',  21, 24, 0, 0, 3],
-    16 => [:conditional, :separator,  '|',    25, 26, 0, 0, 3],
-    18 => [:conditional, :close,      ')',    27, 28, 0, 0, 2],
-    19 => [:conditional, :close,      ')',    28, 29, 0, 0, 1],
-    20 => [:conditional, :separator,  '|',    29, 30, 0, 0, 1],
-    21 => [:conditional, :open,       '(?',   30, 32, 0, 0, 1],
-    22 => [:conditional, :condition,  '(3)',  32, 35, 0, 0, 2],
-    23 => [:conditional, :open,       '(?',   35, 37, 0, 0, 2],
-    24 => [:conditional, :condition,  '(2)',  37, 40, 0, 0, 3],
-    26 => [:conditional, :separator,  '|',    41, 42, 0, 0, 3],
-    28 => [:conditional, :close,      ')',    43, 44, 0, 0, 2],
-    29 => [:conditional, :separator,  '|',    44, 45, 0, 0, 2],
-    30 => [:conditional, :open,       '(?',   45, 47, 0, 0, 2],
-    31 => [:conditional, :condition,  '(1)',  47, 50, 0, 0, 3],
-    33 => [:conditional, :separator,  '|',    51, 52, 0, 0, 3],
-    35 => [:conditional, :close,      ')',    53, 54, 0, 0, 2],
-    36 => [:conditional, :close,      ')',    54, 55, 0, 0, 1],
-    37 => [:conditional, :close,      ')',    55, 56, 0, 0, 0]
-end

data/spec/lexer/delimiters_spec.rb

@@ -1,68 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe('Literal delimiter lexing') do
-  include_examples 'lex', '}',
-    0 => [:literal,     :literal,       '}',       0,  1,  0, 0, 0]
-
-  include_examples 'lex', '}}',
-    0 => [:literal,     :literal,       '}}',      0,  2,  0, 0, 0]
-
-  include_examples 'lex', '{',
-    0 => [:literal,     :literal,       '{',       0,  1,  0, 0, 0]
-
-  include_examples 'lex', '{{',
-    0 => [:literal,     :literal,       '{{',      0,  2,  0, 0, 0]
-
-  include_examples 'lex', '{}',
-    0 => [:literal,     :literal,       '{}',      0,  2,  0, 0, 0]
-
-  include_examples 'lex', '}{',
-    0 => [:literal,     :literal,       '}{',      0,  2,  0, 0, 0]
-
-  include_examples 'lex', '}{+',
-    0 => [:literal,     :literal,       '}',       0,  1,  0, 0, 0],
-    1 => [:literal,     :literal,       '{',       1,  2,  0, 0, 0],
-    2 => [:quantifier,  :one_or_more,   '+',       2,  3,  0, 0, 0]
-
-  include_examples 'lex', '{{var}}',
-    0 => [:literal,     :literal,       '{{var}}',  0,  7,  0, 0, 0]
-
-  include_examples 'lex', 'a{b}c',
-    0 => [:literal,     :literal,       'a{b}c',    0,  5,  0, 0, 0]
-
-  include_examples 'lex', 'a{1,2',
-    0 => [:literal,     :literal,       'a{1,2',    0,  5,  0, 0, 0]
-
-  include_examples 'lex', '({.+})',
-    0 => [:group,       :capture,       '(',    0,  1,  0, 0, 0],
-    1 => [:literal,     :literal,       '{',    1,  2,  1, 0, 0],
-    2 => [:meta,        :dot,           '.',    2,  3,  1, 0, 0],
-    3 => [:quantifier,  :one_or_more,   '+',    3,  4,  1, 0, 0],
-    4 => [:literal,     :literal,       '}',    4,  5,  1, 0, 0],
-    5 => [:group,       :close,         ')',    5,  6,  0, 0, 0]
-
-  include_examples 'lex', ']',
-    0 => [:literal,     :literal,       ']',        0,  1,  0, 0, 0]
-
-  include_examples 'lex', ']]',
-    0 => [:literal,     :literal,       ']]',       0,  2,  0, 0, 0]
-
-  include_examples 'lex', ']\[',
-    0 => [:literal,     :literal,       ']',        0,  1,  0, 0, 0],
-    1 => [:escape,      :set_open,      '\[',       1,  3,  0, 0, 0]
-
-  include_examples 'lex', '()',
-    0 => [:group,       :capture,       '(',        0,  1,  0, 0, 0],
-    1 => [:group,       :close,         ')',        1,  2,  0, 0, 0]
-
-  include_examples 'lex', '{abc:.+}}}[^}]]}',
-    0 => [:literal,     :literal,       '{abc:',    0,  5,  0, 0, 0],
-    1 => [:meta,        :dot,           '.',        5,  6,  0, 0, 0],
-    2 => [:quantifier,  :one_or_more,   '+',        6,  7,  0, 0, 0],
-    3 => [:literal,     :literal,       '}}}',      7,  10, 0, 0, 0],
-    4 => [:set,         :open,          '[',        10, 11, 0, 0, 0],
-    5 => [:set,         :negate,        '^',        11, 12, 0, 1, 0],
-    6 => [:literal,     :literal,       '}',        12, 13, 0, 1, 0],
-    7 => [:set,         :close,         ']',        13, 14, 0, 0, 0],
-    8 => [:literal,     :literal,       ']}',       14, 16, 0, 0, 0]
-end

data/spec/lexer/escapes_spec.rb

@@ -1,14 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe('Escape lexing') do
-  include_examples 'lex', '\u{62}',
-    0 => [:escape,  :codepoint_list, '\u{62}',       0, 6,  0, 0, 0]
-
-  include_examples 'lex', '\u{62 63 64}',
-    0 => [:escape,  :codepoint_list, '\u{62 63 64}', 0, 12, 0, 0, 0]
-
-  include_examples 'lex', '\u{62 63 64}+',
-    0 => [:escape,     :codepoint_list, '\u{62 63}',  0,  9,  0, 0, 0],
-    1 => [:escape,     :codepoint_list, '\u{64}',     9,  15, 0, 0, 0],
-    2 => [:quantifier, :one_or_more,    '+',          15, 16, 0, 0, 0]
-end

data/spec/lexer/keep_spec.rb

@@ -1,10 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe('Keep lexing') do
-  include_examples 'lex', /ab\Kcd/,
-    1 => [:keep, :mark, '\K', 2,  4,  0, 0, 0]
-
-  include_examples 'lex', /(a\Kb)|(c\\\Kd)ef/,
-    2 => [:keep, :mark, '\K', 2,  4,  1, 0, 0],
-    9 => [:keep, :mark, '\K', 11, 13, 1, 0, 0]
-end

data/spec/lexer/literals_spec.rb

@@ -1,64 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe('Literal lexing') do
-  # ascii, single byte characters
-  include_examples 'lex', 'a',
-    0 => [:literal,     :literal,       'a',        0, 1, 0, 0, 0]
-
-  include_examples 'lex', 'ab+',
-    0 => [:literal,     :literal,       'a',        0, 1, 0, 0, 0],
-    1 => [:literal,     :literal,       'b',        1, 2, 0, 0, 0],
-    2 => [:quantifier,  :one_or_more,   '+',        2, 3, 0, 0, 0]
-
-  # 2 byte wide characters
-  include_examples 'lex', 'äöü+',
-    0 => [:literal,     :literal,       'äö',       0, 2, 0, 0, 0],
-    1 => [:literal,     :literal,       'ü',        2, 3, 0, 0, 0],
-    2 => [:quantifier,  :one_or_more,   '+',        3, 4, 0, 0, 0]
-
-  # 3 byte wide characters, Japanese
-  include_examples 'lex', 'ab?れます+cd',
-    0 => [:literal,     :literal,       'a',        0, 1, 0, 0, 0],
-    1 => [:literal,     :literal,       'b',        1, 2, 0, 0, 0],
-    2 => [:quantifier,  :zero_or_one,   '?',        2, 3, 0, 0, 0],
-    3 => [:literal,     :literal,       'れま',     3, 5, 0, 0, 0],
-    4 => [:literal,     :literal,       'す',       5, 6, 0, 0, 0],
-    5 => [:quantifier,  :one_or_more,   '+',        6, 7, 0, 0, 0],
-    6 => [:literal,     :literal,       'cd',       7, 9, 0, 0, 0]
-
-  # 4 byte wide characters, Osmanya
-  include_examples 'lex', '𐒀𐒁?𐒂ab+𐒃',
-    0 => [:literal,     :literal,       '𐒀',        0, 1, 0, 0, 0],
-    1 => [:literal,     :literal,       '𐒁',        1, 2, 0, 0, 0],
-    2 => [:quantifier,  :zero_or_one,   '?',        2, 3, 0, 0, 0],
-    3 => [:literal,     :literal,       '𐒂a',       3, 5, 0, 0, 0],
-    4 => [:literal,     :literal,       'b',        5, 6, 0, 0, 0],
-    5 => [:quantifier,  :one_or_more,   '+',        6, 7, 0, 0, 0],
-    6 => [:literal,     :literal,       '𐒃',        7, 8, 0, 0, 0]
-
-  include_examples 'lex', 'mu𝄞?si*𝄫c+',
-    0 => [:literal,     :literal,       'mu',       0, 2, 0, 0, 0],
-    1 => [:literal,     :literal,       '𝄞',        2, 3, 0, 0, 0],
-    2 => [:quantifier,  :zero_or_one,   '?',        3, 4, 0, 0, 0],
-    3 => [:literal,     :literal,       's',        4, 5, 0, 0, 0],
-    4 => [:literal,     :literal,       'i',        5, 6, 0, 0, 0],
-    5 => [:quantifier,  :zero_or_more,  '*',        6, 7, 0, 0, 0],
-    6 => [:literal,     :literal,       '𝄫',        7, 8, 0, 0, 0],
-    7 => [:literal,     :literal,       'c',        8, 9, 0, 0, 0],
-    8 => [:quantifier,  :one_or_more,   '+',        9, 10, 0, 0, 0]
-
-  specify('lex single 2 byte char') do
-    tokens = RL.lex("\u0627+")
-    expect(tokens.count).to eq 2
-  end
-
-  specify('lex single 3 byte char') do
-    tokens = RL.lex("\u308C+")
-    expect(tokens.count).to eq 2
-  end
-
-  specify('lex single 4 byte char') do
-    tokens = RL.lex("\u{1D11E}+")
-    expect(tokens.count).to eq 2
-  end
-end

data/spec/lexer/nesting_spec.rb

@@ -1,99 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe('Nesting lexing') do
-  include_examples 'lex', /(((b)))/,
-    0 => [:group,    :capture,   '(',  0,  1, 0, 0, 0],
-    1 => [:group,    :capture,   '(',  1,  2, 1, 0, 0],
-    2 => [:group,    :capture,   '(',  2,  3, 2, 0, 0],
-    3 => [:literal,  :literal,   'b',  3,  4, 3, 0, 0],
-    4 => [:group,    :close,     ')',  4,  5, 2, 0, 0],
-    5 => [:group,    :close,     ')',  5,  6, 1, 0, 0],
-    6 => [:group,    :close,     ')',  6,  7, 0, 0, 0]
-
-  include_examples 'lex', /(\((b)\))/,
-    0 => [:group,    :capture,      '(',   0,  1, 0, 0, 0],
-    1 => [:escape,   :group_open,   '\(',  1,  3, 1, 0, 0],
-    2 => [:group,    :capture,      '(',   3,  4, 1, 0, 0],
-    3 => [:literal,  :literal,      'b',   4,  5, 2, 0, 0],
-    4 => [:group,    :close,        ')',   5,  6, 1, 0, 0],
-    5 => [:escape,   :group_close,  '\)',  6,  8, 1, 0, 0],
-    6 => [:group,    :close,        ')',   8,  9, 0, 0, 0]
-
-  include_examples 'lex', /(?>a(?>b(?>c)))/,
-    0 => [:group,    :atomic,       '(?>',  0,  3, 0, 0, 0],
-    2 => [:group,    :atomic,       '(?>',  4,  7, 1, 0, 0],
-    4 => [:group,    :atomic,       '(?>',  8, 11, 2, 0, 0],
-    6 => [:group,    :close,        ')',   12, 13, 2, 0, 0],
-    7 => [:group,    :close,        ')',   13, 14, 1, 0, 0],
-    8 => [:group,    :close,        ')',   14, 15, 0, 0, 0]
-
-  include_examples 'lex', /(?:a(?:b(?:c)))/,
-    0 => [:group,       :passive,       '(?:',    0,  3, 0, 0, 0],
-    2 => [:group,       :passive,       '(?:',    4,  7, 1, 0, 0],
-    4 => [:group,       :passive,       '(?:',    8, 11, 2, 0, 0],
-    6 => [:group,       :close,         ')',     12, 13, 2, 0, 0],
-    7 => [:group,       :close,         ')',     13, 14, 1, 0, 0],
-    8 => [:group,       :close,         ')',     14, 15, 0, 0, 0]
-
-  include_examples 'lex', /(?=a(?!b(?<=c(?<!d))))/,
-    0  => [:assertion,   :lookahead,     '(?=',    0,  3, 0, 0, 0],
-    2  => [:assertion,   :nlookahead,    '(?!',    4,  7, 1, 0, 0],
-    4  => [:assertion,   :lookbehind,    '(?<=',   8, 12, 2, 0, 0],
-    6  => [:assertion,   :nlookbehind,   '(?<!',  13, 17, 3, 0, 0],
-    8  => [:group,       :close,         ')',     18, 19, 3, 0, 0],
-    9  => [:group,       :close,         ')',     19, 20, 2, 0, 0],
-    10 => [:group,       :close,         ')',     20, 21, 1, 0, 0],
-    11 => [:group,       :close,         ')',     21, 22, 0, 0, 0]
-
-  include_examples 'lex', /((?#a)b(?#c)d(?#e))/,
-    0 => [:group,       :capture,       '(',      0,  1, 0, 0, 0],
-    1 => [:group,       :comment,       '(?#a)',  1,  6, 1, 0, 0],
-    3 => [:group,       :comment,       '(?#c)',  7, 12, 1, 0, 0],
-    5 => [:group,       :comment,       '(?#e)', 13, 18, 1, 0, 0],
-    6 => [:group,       :close,         ')',     18, 19, 0, 0, 0]
-
-  include_examples 'lex', /a[b-e]f/,
-    1 => [:set,         :open,          '[',      1,  2, 0, 0, 0],
-    2 => [:literal,     :literal,       'b',      2,  3, 0, 1, 0],
-    3 => [:set,         :range,         '-',      3,  4, 0, 1, 0],
-    4 => [:literal,     :literal,       'e',      4,  5, 0, 1, 0],
-    5 => [:set,         :close,         ']',      5,  6, 0, 0, 0]
-
-  include_examples 'lex', /[[:word:]&&[^c]z]/,
-    0 => [:set,         :open,          '[',          0,  1, 0, 0, 0],
-    1 => [:posixclass,  :word,          '[:word:]',   1,  9, 0, 1, 0],
-    2 => [:set,         :intersection,  '&&',         9, 11, 0, 1, 0],
-    3 => [:set,         :open,          '[',         11, 12, 0, 1, 0],
-    4 => [:set,         :negate,        '^',         12, 13, 0, 2, 0],
-    5 => [:literal,     :literal,       'c',         13, 14, 0, 2, 0],
-    6 => [:set,         :close,         ']',         14, 15, 0, 1, 0],
-    7 => [:literal,     :literal,       'z',         15, 16, 0, 1, 0],
-    8 => [:set,         :close,         ']',         16, 17, 0, 0, 0]
-
-  include_examples 'lex', /[\p{word}&&[^c]z]/,
-    0 => [:set,         :open,          '[',          0,  1, 0, 0, 0],
-    1 => [:property,    :word,          '\p{word}',   1,  9, 0, 1, 0],
-    2 => [:set,         :intersection,  '&&',         9, 11, 0, 1, 0],
-    3 => [:set,         :open,          '[',         11, 12, 0, 1, 0],
-    4 => [:set,         :negate,        '^',         12, 13, 0, 2, 0],
-    5 => [:literal,     :literal,       'c',         13, 14, 0, 2, 0],
-    6 => [:set,         :close,         ']',         14, 15, 0, 1, 0],
-    7 => [:literal,     :literal,       'z',         15, 16, 0, 1, 0],
-    8 => [:set,         :close,         ']',         16, 17, 0, 0, 0]
-
-  include_examples 'lex', /[a[b[c[d-g]]]]/,
-    0  => [:set,         :open,          '[',      0,  1, 0, 0, 0],
-    1  => [:literal,     :literal,       'a',      1,  2, 0, 1, 0],
-    2  => [:set,         :open,          '[',      2,  3, 0, 1, 0],
-    3  => [:literal,     :literal,       'b',      3,  4, 0, 2, 0],
-    4  => [:set,         :open,          '[',      4,  5, 0, 2, 0],
-    5  => [:literal,     :literal,       'c',      5,  6, 0, 3, 0],
-    6  => [:set,         :open,          '[',      6,  7, 0, 3, 0],
-    7  => [:literal,     :literal,       'd',      7,  8, 0, 4, 0],
-    8  => [:set,         :range,         '-',      8,  9, 0, 4, 0],
-    9  => [:literal,     :literal,       'g',      9, 10, 0, 4, 0],
-    10 => [:set,         :close,         ']',     10, 11, 0, 3, 0],
-    11 => [:set,         :close,         ']',     11, 12, 0, 2, 0],
-    12 => [:set,         :close,         ']',     12, 13, 0, 1, 0],
-    13 => [:set,         :close,         ']',     13, 14, 0, 0, 0]
-end

data/spec/lexer/refcalls_spec.rb

@@ -1,60 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe('RefCall lexing') do
-  # Traditional numerical group back-reference
-  include_examples 'lex', '(abc)\1',
-    3 => [:backref, :number,                '\1',         5,  7, 0, 0, 0]
-
-  # Group back-references, named, numbered, and relative
-  include_examples 'lex', '(?<X>abc)\k<X>',
-    3 => [:backref, :name_ref,              '\k<X>',      9, 14, 0, 0, 0]
-  include_examples 'lex', "(?<X>abc)\\k'X'",
-    3 => [:backref, :name_ref,              "\\k'X'",     9, 14, 0, 0, 0]
-
-  include_examples 'lex', '(abc)\k<1>',
-    3 => [:backref, :number_ref,            '\k<1>',      5, 10, 0, 0, 0]
-  include_examples 'lex', "(abc)\\k'1'",
-    3 => [:backref, :number_ref,            "\\k'1'",     5, 10, 0, 0, 0]
-
-  include_examples 'lex', '(abc)\k<-1>',
-    3 => [:backref, :number_rel_ref,        '\k<-1>',     5, 11, 0, 0, 0]
-  include_examples 'lex', "(abc)\\k'-1'",
-    3 => [:backref, :number_rel_ref,        "\\k'-1'",    5, 11, 0, 0, 0]
-
-  # Sub-expression invocation, named, numbered, and relative
-  include_examples 'lex', '(?<X>abc)\g<X>',
-    3 => [:backref, :name_call,             '\g<X>',      9, 14, 0, 0, 0]
-  include_examples 'lex', "(?<X>abc)\\g'X'",
-    3 => [:backref, :name_call,             "\\g'X'",     9, 14, 0, 0, 0]
-
-  include_examples 'lex', '(abc)\g<1>',
-    3 => [:backref, :number_call,           '\g<1>',      5, 10, 0, 0, 0]
-  include_examples 'lex', "(abc)\\g'1'",
-    3 => [:backref, :number_call,           "\\g'1'",     5, 10, 0, 0, 0]
-
-  include_examples 'lex', '\g<0>',
-    0 => [:backref, :number_call,           '\g<0>',      0,  5, 0, 0, 0]
-  include_examples 'lex', "\\g'0'",
-    0 => [:backref, :number_call,           "\\g'0'",     0,  5, 0, 0, 0]
-
-  include_examples 'lex', '(abc)\g<-1>',
-    3 => [:backref, :number_rel_call,       '\g<-1>',     5, 11, 0, 0, 0]
-  include_examples 'lex', "(abc)\\g'-1'",
-    3 => [:backref, :number_rel_call,       "\\g'-1'",    5, 11, 0, 0, 0]
-
-  include_examples 'lex', '(abc)\g<+1>',
-    3 => [:backref, :number_rel_call,       '\g<+1>',     5, 11, 0, 0, 0]
-  include_examples 'lex', "(abc)\\g'+1'",
-    3 => [:backref, :number_rel_call,       "\\g'+1'",    5, 11, 0, 0, 0]
-
-  # Group back-references, with nesting level
-  include_examples 'lex', '(?<X>abc)\k<X-0>',
-    3 => [:backref, :name_recursion_ref,    '\k<X-0>',    9, 16, 0, 0, 0]
-  include_examples 'lex', "(?<X>abc)\\k'X-0'",
-    3 => [:backref, :name_recursion_ref,    "\\k'X-0'",   9, 16, 0, 0, 0]
-
-  include_examples 'lex', '(abc)\k<1-0>',
-    3 => [:backref, :number_recursion_ref,  '\k<1-0>',    5, 12, 0, 0, 0]
-  include_examples 'lex', "(abc)\\k'1-0'",
-    3 => [:backref, :number_recursion_ref,  "\\k'1-0'",   5, 12, 0, 0, 0]
-end

data/spec/parser/all_spec.rb

@@ -1,43 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe(Regexp::Parser) do
-  specify('parse returns a root expression') do
-    expect(RP.parse('abc')).to be_instance_of(Root)
-  end
-
-  specify('parse can be called with block') do
-    expect(RP.parse('abc') { |root| root.class }).to eq Root
-  end
-
-  specify('parse root contains expressions') do
-    root = RP.parse(/^a.c+[^one]{2,3}\b\d\\\C-C$/)
-    expect(root.expressions).to all(be_a Regexp::Expression::Base)
-  end
-
-  specify('parse root options mi') do
-    root = RP.parse(/[abc]/mi, 'ruby/1.8')
-
-    expect(root.m?).to be true
-    expect(root.i?).to be true
-    expect(root.x?).to be false
-  end
-
-  specify('parse node types') do
-    root = RP.parse('^(one){2,3}([^d\\]efm-qz\\,\\-]*)(ghi)+$')
-
-    expect(root[1][0]).to be_a(Literal)
-    expect(root[1]).to be_quantified
-    expect(root[2][0]).to be_a(CharacterSet)
-    expect(root[2]).not_to be_quantified
-    expect(root[3]).to be_a(Group::Capture)
-    expect(root[3]).to be_quantified
-  end
-
-  specify('parse no quantifier target raises error') do
-    expect { RP.parse('?abc') }.to raise_error(Regexp::Parser::Error)
-  end
-
-  specify('parse sequence no quantifier target raises error') do
-    expect { RP.parse('abc|?def') }.to raise_error(Regexp::Parser::Error)
-  end
-end

data/spec/parser/alternation_spec.rb

@@ -1,88 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe('Alternation parsing') do
-  let(:root) { RP.parse('(ab??|cd*|ef+)*|(gh|ij|kl)?') }
-
-  specify('parse alternation root') do
-    e = root[0]
-    expect(e).to be_a(Alternation)
-  end
-
-  specify('parse alternation alts') do
-    alts = root[0].alternatives
-
-    expect(alts[0]).to be_a(Alternative)
-    expect(alts[1]).to be_a(Alternative)
-
-    expect(alts[0][0]).to be_a(Group::Capture)
-    expect(alts[1][0]).to be_a(Group::Capture)
-
-    expect(alts.length).to eq 2
-  end
-
-  specify('parse alternation nested') do
-    e = root[0].alternatives[0][0][0]
-
-    expect(e).to be_a(Alternation)
-  end
-
-  specify('parse alternation nested sequence') do
-    alts = root[0][0]
-    nested = alts[0][0][0]
-
-    expect(nested).to be_a(Alternative)
-
-    expect(nested[0]).to be_a(Literal)
-    expect(nested[1]).to be_a(Literal)
-    expect(nested.expressions.length).to eq 2
-  end
-
-  specify('parse alternation nested groups') do
-    root = RP.parse('(i|ey|([ougfd]+)|(ney))')
-
-    alts = root[0][0].alternatives
-    expect(alts.length).to eq 4
-  end
-
-  specify('parse alternation grouped alts') do
-    root = RP.parse('ca((n)|(t)|(ll)|(b))')
-
-    alts = root[1][0].alternatives
-
-    expect(alts.length).to eq 4
-
-    expect(alts[0]).to be_a(Alternative)
-    expect(alts[1]).to be_a(Alternative)
-    expect(alts[2]).to be_a(Alternative)
-    expect(alts[3]).to be_a(Alternative)
-  end
-
-  specify('parse alternation nested grouped alts') do
-    root = RP.parse('ca((n|t)|(ll|b))')
-
-    alts = root[1][0].alternatives
-
-    expect(alts.length).to eq 2
-
-    expect(alts[0]).to be_a(Alternative)
-    expect(alts[1]).to be_a(Alternative)
-
-    subalts = root[1][0][0][0][0].alternatives
-
-    expect(alts.length).to eq 2
-
-    expect(subalts[0]).to be_a(Alternative)
-    expect(subalts[1]).to be_a(Alternative)
-  end
-
-  specify('parse alternation continues after nesting') do
-    root = RP.parse(/a|(b)c/)
-
-    seq = root[0][1].expressions
-
-    expect(seq.length).to eq 2
-
-    expect(seq[0]).to be_a(Group::Capture)
-    expect(seq[1]).to be_a(Literal)
-  end
-end

data/spec/parser/anchors_spec.rb

@@ -1,17 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe('Anchor parsing') do
-  include_examples 'parse', /^a/,   0 =>  [:anchor,   :bol,               Anchor::BOL]
-  include_examples 'parse', /a$/,   1 =>  [:anchor,   :eol,               Anchor::EOL]
-
-  include_examples 'parse', /\Aa/,  0 =>  [:anchor,   :bos,               Anchor::BOS]
-  include_examples 'parse', /a\z/,  1 =>  [:anchor,   :eos,               Anchor::EOS]
-  include_examples 'parse', /a\Z/,  1 =>  [:anchor,   :eos_ob_eol,        Anchor::EOSobEOL]
-
-  include_examples 'parse', /a\b/,  1 =>  [:anchor,   :word_boundary,     Anchor::WordBoundary]
-  include_examples 'parse', /a\B/,  1 =>  [:anchor,   :nonword_boundary,  Anchor::NonWordBoundary]
-
-  include_examples 'parse', /a\G/,  1 =>  [:anchor,   :match_start,       Anchor::MatchStart]
-
-  include_examples 'parse', /\\A/,  0 =>  [:escape,   :backslash,         EscapeSequence::Literal]
-end