regexp_parser 1.7.0 → 2.9.0

data/spec/expression/methods/strfregexp_spec.rb

@@ -1,224 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe('Expression#strfregexp') do
-  specify('#strfre alias') do
-    expect(RP.parse(/a/)).to respond_to(:strfre)
-  end
-
-  specify('#strfregexp level') do
-    root = RP.parse(/a(b(c))/)
-
-    expect(root.strfregexp('%l')).to eq 'root'
-
-    a = root.first
-    expect(a.strfregexp('%%l')).to eq '%0'
-
-    b = root[1].first
-    expect(b.strfregexp('<%l>')).to eq '<1>'
-
-    c = root[1][1].first
-    expect(c.strfregexp('[at: %l]')).to eq '[at: 2]'
-  end
-
-  specify('#strfregexp start end') do
-    root = RP.parse(/a(b(c))/)
-
-    expect(root.strfregexp('%s')).to eq '0'
-    expect(root.strfregexp('%e')).to eq '7'
-
-    a = root.first
-    expect(a.strfregexp('%%s')).to eq '%0'
-    expect(a.strfregexp('%e')).to eq '1'
-
-    group_1 = root[1]
-    expect(group_1.strfregexp('GRP:%s')).to eq 'GRP:1'
-    expect(group_1.strfregexp('%e')).to eq '7'
-
-    b = group_1.first
-    expect(b.strfregexp('<@%s>')).to eq '<@2>'
-    expect(b.strfregexp('%e')).to eq '3'
-
-    c = group_1.last.first
-    expect(c.strfregexp('[at: %s]')).to eq '[at: 4]'
-    expect(c.strfregexp('%e')).to eq '5'
-  end
-
-  specify('#strfregexp length') do
-    root = RP.parse(/a[b]c/)
-
-    expect(root.strfregexp('%S')).to eq '5'
-
-    a = root.first
-    expect(a.strfregexp('%S')).to eq '1'
-
-    set = root[1]
-    expect(set.strfregexp('%S')).to eq '3'
-  end
-
-  specify('#strfregexp coded offset') do
-    root = RP.parse(/a[b]c/)
-
-    expect(root.strfregexp('%o')).to eq '@0+5'
-
-    a = root.first
-    expect(a.strfregexp('%o')).to eq '@0+1'
-
-    set = root[1]
-    expect(set.strfregexp('%o')).to eq '@1+3'
-  end
-
-  specify('#strfregexp type token') do
-    root = RP.parse(/a[b](c)/)
-
-    expect(root.strfregexp('%y')).to eq 'expression'
-    expect(root.strfregexp('%k')).to eq 'root'
-    expect(root.strfregexp('%i')).to eq 'expression:root'
-    expect(root.strfregexp('%c')).to eq 'Regexp::Expression::Root'
-
-    a = root.first
-    expect(a.strfregexp('%y')).to eq 'literal'
-    expect(a.strfregexp('%k')).to eq 'literal'
-    expect(a.strfregexp('%i')).to eq 'literal:literal'
-    expect(a.strfregexp('%c')).to eq 'Regexp::Expression::Literal'
-
-    set = root[1]
-    expect(set.strfregexp('%y')).to eq 'set'
-    expect(set.strfregexp('%k')).to eq 'character'
-    expect(set.strfregexp('%i')).to eq 'set:character'
-    expect(set.strfregexp('%c')).to eq 'Regexp::Expression::CharacterSet'
-
-    group = root.last
-    expect(group.strfregexp('%y')).to eq 'group'
-    expect(group.strfregexp('%k')).to eq 'capture'
-    expect(group.strfregexp('%i')).to eq 'group:capture'
-    expect(group.strfregexp('%c')).to eq 'Regexp::Expression::Group::Capture'
-  end
-
-  specify('#strfregexp quantifier') do
-    root = RP.parse(/a+[b](c)?d{3,4}/)
-
-    expect(root.strfregexp('%q')).to eq '{1}'
-    expect(root.strfregexp('%Q')).to eq ''
-    expect(root.strfregexp('%z, %Z')).to eq '1, 1'
-
-    a = root.first
-    expect(a.strfregexp('%q')).to eq '{1, or-more}'
-    expect(a.strfregexp('%Q')).to eq '+'
-    expect(a.strfregexp('%z, %Z')).to eq '1, -1'
-
-    set = root[1]
-    expect(set.strfregexp('%q')).to eq '{1}'
-    expect(set.strfregexp('%Q')).to eq ''
-    expect(set.strfregexp('%z, %Z')).to eq '1, 1'
-
-    group = root[2]
-    expect(group.strfregexp('%q')).to eq '{0, 1}'
-    expect(group.strfregexp('%Q')).to eq '?'
-    expect(group.strfregexp('%z, %Z')).to eq '0, 1'
-
-    d = root.last
-    expect(d.strfregexp('%q')).to eq '{3, 4}'
-    expect(d.strfregexp('%Q')).to eq '{3,4}'
-    expect(d.strfregexp('%z, %Z')).to eq '3, 4'
-  end
-
-  specify('#strfregexp text') do
-    root = RP.parse(/a(b(c))|[d-gk-p]+/)
-
-    expect(root.strfregexp('%t')).to eq 'a(b(c))|[d-gk-p]+'
-    expect(root.strfregexp('%~t')).to eq 'expression:root'
-
-    alt = root.first
-    expect(alt.strfregexp('%t')).to eq 'a(b(c))|[d-gk-p]+'
-    expect(alt.strfregexp('%T')).to eq 'a(b(c))|[d-gk-p]+'
-    expect(alt.strfregexp('%~t')).to eq 'meta:alternation'
-
-    seq_1 = alt.first
-    expect(seq_1.strfregexp('%t')).to eq 'a(b(c))'
-    expect(seq_1.strfregexp('%T')).to eq 'a(b(c))'
-    expect(seq_1.strfregexp('%~t')).to eq 'expression:sequence'
-
-    group = seq_1[1]
-    expect(group.strfregexp('%t')).to eq '(b(c))'
-    expect(group.strfregexp('%T')).to eq '(b(c))'
-    expect(group.strfregexp('%~t')).to eq 'group:capture'
-
-    seq_2 = alt.last
-    expect(seq_2.strfregexp('%t')).to eq '[d-gk-p]+'
-    expect(seq_2.strfregexp('%T')).to eq '[d-gk-p]+'
-
-    set = seq_2.first
-    expect(set.strfregexp('%t')).to eq '[d-gk-p]'
-    expect(set.strfregexp('%T')).to eq '[d-gk-p]+'
-    expect(set.strfregexp('%~t')).to eq 'set:character'
-  end
-
-  specify('#strfregexp combined') do
-    root = RP.parse(/a{5}|[b-d]+/)
-
-    expect(root.strfregexp('%b')).to eq '@0+11 expression:root'
-    expect(root.strfregexp('%b')).to eq root.strfregexp('%o %i')
-
-    expect(root.strfregexp('%m')).to eq '@0+11 expression:root {1}'
-    expect(root.strfregexp('%m')).to eq root.strfregexp('%b %q')
-
-    expect(root.strfregexp('%a')).to eq '@0+11 expression:root {1} a{5}|[b-d]+'
-    expect(root.strfregexp('%a')).to eq root.strfregexp('%m %t')
-  end
-
-  specify('#strfregexp conditional') do
-    root = RP.parse('(?<A>a)(?(<A>)b|c)', 'ruby/2.0')
-
-    expect { root.strfregexp }.not_to(raise_error)
-  end
-
-  specify('#strfregexp_tree') do
-    root = RP.parse(/a[b-d]*(e(f+))?/)
-
-    expect(root.strfregexp_tree('%>%o %~t')).to eq(
-      "@0+15 expression:root\n" +
-      "  @0+1 a\n" +
-      "  @1+6 set:character\n" +
-      "    @2+3 set:range\n" +
-      "      @2+1 b\n" +
-      "      @4+1 d\n" +
-      "  @7+8 group:capture\n" +
-      "    @8+1 e\n" +
-      "    @9+4 group:capture\n" +
-      "      @10+2 f+"
-    )
-  end
-
-  specify('#strfregexp_tree separator') do
-    root = RP.parse(/a[b-d]*(e(f+))?/)
-
-    expect(root.strfregexp_tree('%>%o %~t', true, '-SEP-')).to eq(
-      "@0+15 expression:root-SEP-" +
-      "  @0+1 a-SEP-" +
-      "  @1+6 set:character-SEP-" +
-      "    @2+3 set:range-SEP-" +
-      "      @2+1 b-SEP-" +
-      "      @4+1 d-SEP-" +
-      "  @7+8 group:capture-SEP-" +
-      "    @8+1 e-SEP-" +
-      "    @9+4 group:capture-SEP-" +
-      "      @10+2 f+"
-    )
-  end
-
-  specify('#strfregexp_tree excluding self') do
-    root = RP.parse(/a[b-d]*(e(f+))?/)
-
-    expect(root.strfregexp_tree('%>%o %~t', false)).to eq(
-      "@0+1 a\n" +
-      "@1+6 set:character\n" +
-      "  @2+3 set:range\n" +
-      "    @2+1 b\n" +
-      "    @4+1 d\n" +
-      "@7+8 group:capture\n" +
-      "  @8+1 e\n" +
-      "  @9+4 group:capture\n" +
-      "    @10+2 f+"
-    )
-  end
-end

data/spec/expression/methods/tests_spec.rb

@@ -1,99 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe('ExpressionTests') do
-  specify('#type?') do
-    root = RP.parse(/abcd|(ghij)|[klmn]/)
-
-    alt = root.first
-
-    expect(alt.type?(:meta)).to be true
-    expect(alt.type?(:escape)).to be false
-    expect(alt.type?(%i[meta escape])).to be true
-    expect(alt.type?(%i[literal escape])).to be false
-    expect(alt.type?(:*)).to be true
-    expect(alt.type?([:*])).to be true
-    expect(alt.type?(%i[literal escape *])).to be true
-
-    seq_1 = alt[0]
-    expect(seq_1.type?(:expression)).to be true
-    expect(seq_1.first.type?(:literal)).to be true
-
-    seq_2 = alt[1]
-    expect(seq_2.type?(:*)).to be true
-    expect(seq_2.first.type?(:group)).to be true
-
-    seq_3 = alt[2]
-    expect(seq_3.first.type?(:set)).to be true
-  end
-
-  specify('#is?') do
-    root = RP.parse(/.+|\.?/)
-
-    expect(root.is?(:*)).to be true
-
-    alt = root.first
-    expect(alt.is?(:*)).to be true
-    expect(alt.is?(:alternation)).to be true
-    expect(alt.is?(:alternation, :meta)).to be true
-
-    seq_1 = alt[0]
-    expect(seq_1.is?(:sequence)).to be true
-    expect(seq_1.is?(:sequence, :expression)).to be true
-
-    expect(seq_1.first.is?(:dot)).to be true
-    expect(seq_1.first.is?(:dot, :escape)).to be false
-    expect(seq_1.first.is?(:dot, :meta)).to be true
-    expect(seq_1.first.is?(:dot, %i[escape meta])).to be true
-
-    seq_2 = alt[1]
-    expect(seq_2.first.is?(:dot)).to be true
-    expect(seq_2.first.is?(:dot, :escape)).to be true
-    expect(seq_2.first.is?(:dot, :meta)).to be false
-    expect(seq_2.first.is?(:dot, %i[meta escape])).to be true
-  end
-
-  specify('#one_of?') do
-    root = RP.parse(/\Aab(c[\w])d|e.\z/)
-
-    expect(root.one_of?(:*)).to be true
-    expect(root.one_of?(:* => :*)).to be true
-    expect(root.one_of?(:* => [:*])).to be true
-
-    alt = root.first
-    expect(alt.one_of?(:*)).to be true
-    expect(alt.one_of?(:meta)).to be true
-    expect(alt.one_of?(:meta, :alternation)).to be true
-    expect(alt.one_of?(meta: %i[dot bogus])).to be false
-    expect(alt.one_of?(meta: %i[dot alternation])).to be true
-
-    seq_1 = alt[0]
-    expect(seq_1.one_of?(:expression)).to be true
-    expect(seq_1.one_of?(expression: :sequence)).to be true
-
-    expect(seq_1.first.one_of?(:anchor)).to be true
-    expect(seq_1.first.one_of?(anchor: :bos)).to be true
-    expect(seq_1.first.one_of?(anchor: :eos)).to be false
-    expect(seq_1.first.one_of?(anchor: %i[escape meta bos])).to be true
-    expect(seq_1.first.one_of?(anchor: %i[escape meta eos])).to be false
-
-    seq_2 = alt[1]
-    expect(seq_2.first.one_of?(:literal)).to be true
-
-    expect(seq_2[1].one_of?(:meta)).to be true
-    expect(seq_2[1].one_of?(meta: :dot)).to be true
-    expect(seq_2[1].one_of?(meta: :alternation)).to be false
-    expect(seq_2[1].one_of?(meta: [:dot])).to be true
-
-    expect(seq_2.last.one_of?(:group)).to be false
-    expect(seq_2.last.one_of?(group: [:*])).to be false
-    expect(seq_2.last.one_of?(group: [:*], meta: :*)).to be false
-
-    expect(seq_2.last.one_of?(:meta => [:*], :* => :*)).to be true
-    expect(seq_2.last.one_of?(meta: [:*], anchor: :*)).to be true
-    expect(seq_2.last.one_of?(meta: [:*], anchor: :eos)).to be true
-    expect(seq_2.last.one_of?(meta: [:*], anchor: [:bos])).to be false
-    expect(seq_2.last.one_of?(meta: [:*], anchor: %i[bos eos])).to be true
-
-    expect { root.one_of?(Object.new) }.to raise_error(ArgumentError)
-  end
-end

data/spec/expression/methods/traverse_spec.rb

@@ -1,161 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe('Subexpression#traverse') do
-  specify('Subexpression#traverse') do
-    root = RP.parse(/a(b(c(d)))|g[h-i]j|klmn/)
-
-    enters = 0
-    visits = 0
-    exits = 0
-
-    root.traverse do |event, _exp, _index|
-      enters = (enters + 1) if event == :enter
-      visits = (visits + 1) if event == :visit
-      exits = (exits + 1) if event == :exit
-    end
-
-    expect(enters).to eq 9
-    expect(enters).to eq exits
-
-    expect(visits).to eq 9
-  end
-
-  specify('Subexpression#traverse including self') do
-    root = RP.parse(/a(b(c(d)))|g[h-i]j|klmn/)
-
-    enters = 0
-    visits = 0
-    exits = 0
-
-    root.traverse(true) do |event, _exp, _index|
-      enters = (enters + 1) if event == :enter
-      visits = (visits + 1) if event == :visit
-      exits = (exits + 1) if event == :exit
-    end
-
-    expect(enters).to eq 10
-    expect(enters).to eq exits
-
-    expect(visits).to eq 9
-  end
-
-  specify('Subexpression#traverse without a block') do
-    root = RP.parse(/abc/)
-    enum = root.traverse
-
-    expect(enum).to be_a(Enumerator)
-    event, expr, idx = enum.next
-    expect(event).to eq(:visit)
-    expect(expr).to be_a(Regexp::Expression::Literal)
-    expect(idx).to eq(0)
-  end
-
-  specify('Subexpression#walk alias') do
-    root = RP.parse(/abc/)
-
-    expect(root).to respond_to(:walk)
-  end
-
-  specify('Subexpression#each_expression') do
-    root = RP.parse(/a(?x:b(c))|g[h-k]/)
-
-    count = 0
-    root.each_expression { count += 1 }
-
-    expect(count).to eq 13
-  end
-
-  specify('Subexpression#each_expression including self') do
-    root = RP.parse(/a(?x:b(c))|g[h-k]/)
-
-    count = 0
-    root.each_expression(true) { count += 1 }
-
-    expect(count).to eq 14
-  end
-
-  specify('Subexpression#each_expression indices') do
-    root = RP.parse(/a(b)c/)
-
-    indices = []
-    root.each_expression { |_exp, index| (indices << index) }
-
-    expect(indices).to eq [0, 1, 0, 2]
-  end
-
-  specify('Subexpression#each_expression indices including self') do
-    root = RP.parse(/a(b)c/)
-
-    indices = []
-    root.each_expression(true) { |_exp, index| (indices << index) }
-
-    expect(indices).to eq [0, 0, 1, 0, 2]
-  end
-
-  specify('Subexpression#each_expression without a block') do
-    root = RP.parse(/abc/)
-    enum = root.each_expression
-
-    expect(enum).to be_a(Enumerator)
-    expr, idx = enum.next
-    expect(expr).to be_a(Regexp::Expression::Literal)
-    expect(idx).to eq(0)
-  end
-
-  specify('Subexpression#flat_map without block') do
-    root = RP.parse(/a(b([c-e]+))?/)
-
-    array = root.flat_map
-
-    expect(array).to be_instance_of(Array)
-    expect(array.length).to eq 8
-
-    array.each do |item|
-      expect(item).to be_instance_of(Array)
-      expect(item.length).to eq 2
-      expect(item.first).to be_a(Regexp::Expression::Base)
-      expect(item.last).to be_a(Integer)
-    end
-  end
-
-  specify('Subexpression#flat_map without block including self') do
-    root = RP.parse(/a(b([c-e]+))?/)
-
-    array = root.flat_map(true)
-
-    expect(array).to be_instance_of(Array)
-    expect(array.length).to eq 9
-  end
-
-  specify('Subexpression#flat_map indices') do
-    root = RP.parse(/a(b([c-e]+))?f*g/)
-
-    indices = root.flat_map { |_exp, index| index }
-
-    expect(indices).to eq [0, 1, 0, 1, 0, 0, 0, 1, 2, 3]
-  end
-
-  specify('Subexpression#flat_map indices including self') do
-    root = RP.parse(/a(b([c-e]+))?f*g/)
-
-    indices = root.flat_map(true) { |_exp, index| index }
-
-    expect(indices).to eq [0, 0, 1, 0, 1, 0, 0, 0, 1, 2, 3]
-  end
-
-  specify('Subexpression#flat_map expressions') do
-    root = RP.parse(/a(b(c(d)))/)
-
-    levels = root.flat_map { |exp, _index| [exp.level, exp.text] if exp.terminal? }.compact
-
-    expect(levels).to eq [[0, 'a'], [1, 'b'], [2, 'c'], [3, 'd']]
-  end
-
-  specify('Subexpression#flat_map expressions including self') do
-    root = RP.parse(/a(b(c(d)))/)
-
-    levels = root.flat_map(true) { |exp, _index| [exp.level, exp.to_s] }.compact
-
-    expect(levels).to eq [[nil, 'a(b(c(d)))'], [0, 'a'], [0, '(b(c(d)))'], [1, 'b'], [1, '(c(d))'], [2, 'c'], [2, '(d)'], [3, 'd']]
-  end
-end

data/spec/expression/options_spec.rb

@@ -1,128 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe('Expression#options') do
-  it 'returns a hash of options/flags that affect the expression' do
-    exp = RP.parse(/a/ix)[0]
-    expect(exp).to be_a Literal
-    expect(exp.options).to eq(i: true, x: true)
-  end
-
-  it 'includes options that are locally enabled via special groups' do
-    exp = RP.parse(/(?x)(?m:a)/i)[1][0]
-    expect(exp).to be_a Literal
-    expect(exp.options).to eq(i: true, m: true, x: true)
-  end
-
-  it 'excludes locally disabled options' do
-    exp = RP.parse(/(?x)(?-im:a)/i)[1][0]
-    expect(exp).to be_a Literal
-    expect(exp.options).to eq(x: true)
-  end
-
-  it 'gives correct precedence to negative options' do
-    # Negative options have precedence. E.g. /(?i-i)a/ is case-sensitive.
-    regexp = /(?i-i:a)/
-    expect(regexp).to match 'a'
-    expect(regexp).not_to match 'A'
-
-    exp = RP.parse(regexp)[0][0]
-    expect(exp).to be_a Literal
-    expect(exp.options).to eq({})
-  end
-
-  it 'correctly handles multiple negative option parts' do
-    regexp = /(?--m--mx--) . /mx
-    expect(regexp).to match ' . '
-    expect(regexp).not_to match '.'
-    expect(regexp).not_to match "\n"
-
-    exp = RP.parse(regexp)[2]
-    expect(exp.options).to eq({})
-  end
-
-  it 'gives correct precedence when encountering multiple encoding flags' do
-    # Any encoding flag overrides all previous encoding flags. If there are
-    # multiple encoding flags in an options string, the last one wins.
-    # E.g. /(?dau)\w/ matches UTF8 chars but /(?dua)\w/ only ASCII chars.
-    regexp1 = /(?dau)\w/
-    regexp2 = /(?dua)\w/
-    expect(regexp1).to match 'ü'
-    expect(regexp2).not_to match 'ü'
-
-    exp1 = RP.parse(regexp1)[1]
-    exp2 = RP.parse(regexp2)[1]
-    expect(exp1.options).to eq(u: true)
-    expect(exp2.options).to eq(a: true)
-  end
-
-  it 'is accessible via shortcuts' do
-    exp = Root.build
-
-    expect { exp.options[:i] = true }
-      .to  change { exp.i? }.from(false).to(true)
-      .and change { exp.ignore_case? }.from(false).to(true)
-      .and change { exp.case_insensitive? }.from(false).to(true)
-
-    expect { exp.options[:m] = true }
-      .to  change { exp.m? }.from(false).to(true)
-      .and change { exp.multiline? }.from(false).to(true)
-
-    expect { exp.options[:x] = true }
-      .to  change { exp.x? }.from(false).to(true)
-      .and change { exp.extended? }.from(false).to(true)
-      .and change { exp.free_spacing? }.from(false).to(true)
-
-    expect { exp.options[:a] = true }
-      .to  change { exp.a? }.from(false).to(true)
-      .and change { exp.ascii_classes? }.from(false).to(true)
-
-    expect { exp.options[:d] = true }
-      .to  change { exp.d? }.from(false).to(true)
-      .and change { exp.default_classes? }.from(false).to(true)
-
-    expect { exp.options[:u] = true }
-      .to  change { exp.u? }.from(false).to(true)
-      .and change { exp.unicode_classes? }.from(false).to(true)
-  end
-
-  RSpec.shared_examples '#options' do |regexp, path, klass|
-    it "works for expression class #{klass}" do
-      exp = RP.parse(/#{regexp.source}/i).dig(*path)
-      expect(exp).to be_a(klass)
-      expect(exp).to be_i
-      expect(exp).not_to be_x
-    end
-  end
-
-  include_examples '#options', //, [], Root
-  include_examples '#options', /a/, [0], Literal
-  include_examples '#options', /\A/, [0], Anchor::Base
-  include_examples '#options', /\d/, [0], CharacterType::Base
-  include_examples '#options', /\n/, [0], EscapeSequence::Base
-  include_examples '#options', /\K/, [0], Keep::Mark
-  include_examples '#options', /./, [0], CharacterType::Any
-  include_examples '#options', /(a)/, [0], Group::Base
-  include_examples '#options', /(a)/, [0, 0], Literal
-  include_examples '#options', /(?=a)/, [0], Assertion::Base
-  include_examples '#options', /(?=a)/, [0, 0], Literal
-  include_examples '#options', /(a|b)/, [0], Group::Base
-  include_examples '#options', /(a|b)/, [0, 0], Alternation
-  include_examples '#options', /(a|b)/, [0, 0, 0], Alternative
-  include_examples '#options', /(a|b)/, [0, 0, 0, 0], Literal
-  include_examples '#options', /(a)\1/, [1], Backreference::Base
-  include_examples '#options', /(a)\k<1>/, [1], Backreference::Number
-  include_examples '#options', /(a)\g<1>/, [1], Backreference::NumberCall
-  include_examples '#options', /[a]/, [0], CharacterSet
-  include_examples '#options', /[a]/, [0, 0], Literal
-  include_examples '#options', /[a-z]/, [0, 0], CharacterSet::Range
-  include_examples '#options', /[a-z]/, [0, 0, 0], Literal
-  include_examples '#options', /[a&&z]/, [0, 0], CharacterSet::Intersection
-  include_examples '#options', /[a&&z]/, [0, 0, 0], CharacterSet::IntersectedSequence
-  include_examples '#options', /[a&&z]/, [0, 0, 0, 0], Literal
-  include_examples '#options', /[[:ascii:]]/, [0, 0], PosixClass
-  include_examples '#options', /\p{word}/, [0], UnicodeProperty::Base
-  include_examples '#options', /(a)(?(1)b|c)/, [1], Conditional::Expression
-  include_examples '#options', /(a)(?(1)b|c)/, [1, 0], Conditional::Condition
-  include_examples '#options', /(a)(?(1)b|c)/, [1, 1], Conditional::Branch
-  include_examples '#options', /(a)(?(1)b|c)/, [1, 1, 0], Literal
-end

data/spec/expression/root_spec.rb

@@ -1,9 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe(Regexp::Expression::Root) do
-  describe('#initialize') do
-    it 'supports the old, nonstandard arity for backwards compatibility' do
-      expect { Root.new }.to output.to_stderr
-    end
-  end
-end

data/spec/expression/sequence_spec.rb

@@ -1,9 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe(Regexp::Expression::Sequence) do
-  describe('#initialize') do
-    it 'supports the old, nonstandard arity for backwards compatibility' do
-      expect { Sequence.new(0, 0, 0) }.to output.to_stderr
-    end
-  end
-end

data/spec/expression/subexpression_spec.rb

@@ -1,50 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe(Regexp::Expression::Subexpression) do
-  specify('#ts, #te') do
-    regx = /abcd|ghij|klmn|pqur/
-    root = RP.parse(regx)
-
-    alt = root.first
-
-    { 0 => [0, 4], 1 => [5, 9], 2 => [10, 14], 3 => [15, 19] }.each do |index, span|
-      sequence = alt[index]
-
-      expect(sequence.ts).to eq span[0]
-      expect(sequence.te).to eq span[1]
-    end
-  end
-
-  specify('#nesting_level') do
-    root = RP.parse(/a(b(\d|[ef-g[h]]))/)
-
-    tests = {
-      'a'            => 1,
-      'b'            => 2,
-      '\d|[ef-g[h]]' => 3, # alternation
-      '\d'           => 4, # first alternative
-      '[ef-g[h]]'    => 4, # second alternative
-      'e'            => 5,
-      'f-g'          => 5,
-      'f'            => 6,
-      'g'            => 6,
-      'h'            => 6,
-    }
-
-    root.each_expression do |exp|
-      next unless expected_nesting_level = tests.delete(exp.to_s)
-      expect(expected_nesting_level).to eq exp.nesting_level
-    end
-
-    expect(tests).to be_empty
-  end
-
-  specify('#dig') do
-    root = RP.parse(/(((a)))/)
-
-    expect(root.dig(0).to_s).to eq '(((a)))'
-    expect(root.dig(0, 0, 0, 0).to_s).to eq 'a'
-    expect(root.dig(0, 0, 0, 0, 0)).to be_nil
-    expect(root.dig(3, 7)).to be_nil
-  end
-end