regexp_parser 2.2.0 → 2.2.1

data/spec/expression/methods/match_length_spec.rb

@@ -1,161 +0,0 @@
-require 'spec_helper'
-
-ML = Regexp::MatchLength
-
-RSpec.describe(Regexp::MatchLength) do
-  specify('literal') { expect(ML.of(/a/).minmax).to eq [1, 1] }
-  specify('literal sequence') { expect(ML.of(/abc/).minmax).to eq [3, 3] }
-  specify('dot') { expect(ML.of(/./).minmax).to eq [1, 1] }
-  specify('set') { expect(ML.of(/[abc]/).minmax).to eq [1, 1] }
-  specify('type') { expect(ML.of(/\d/).minmax).to eq [1, 1] }
-  specify('escape') { expect(ML.of(/\n/).minmax).to eq [1, 1] }
-  specify('property') { expect(ML.of(/\p{ascii}/).minmax).to eq [1, 1] }
-  specify('codepoint list') { expect(ML.of(/\u{61 62 63}/).minmax).to eq [3, 3] }
-  specify('multi-char literal') { expect(ML.of(/abc/).minmax).to eq [3, 3] }
-  specify('fixed quantified') { expect(ML.of(/a{5}/).minmax).to eq [5, 5] }
-  specify('range quantified') { expect(ML.of(/a{5,9}/).minmax).to eq [5, 9] }
-  specify('nested quantified') { expect(ML.of(/(a{2}){3,4}/).minmax).to eq [6, 8] }
-  specify('open-end quantified') { expect(ML.of(/a*/).minmax).to eq [0, Float::INFINITY] }
-  specify('empty subexpression') { expect(ML.of(//).minmax).to eq [0, 0] }
-  specify('anchor') { expect(ML.of(/^$/).minmax).to eq [0, 0] }
-  specify('lookaround') { expect(ML.of(/(?=abc)/).minmax).to eq [0, 0] }
-  specify('free space') { expect(ML.of(/   /x).minmax).to eq [0, 0] }
-  specify('comment') { expect(ML.of(/(?#comment)/x).minmax).to eq [0, 0] }
-  specify('backreference') { expect(ML.of(/(abc){2}\1/).minmax).to eq [9, 9] }
-  specify('subexp call') { expect(ML.of(/(abc){2}\g<-1>/).minmax).to eq [9, 9] }
-  specify('alternation') { expect(ML.of(/a|bcde/).minmax).to eq [1, 4] }
-  specify('nested alternation') { expect(ML.of(/a|bc(d|efg)/).minmax).to eq [1, 5] }
-  specify('quantified alternation') { expect(ML.of(/a|bcde?/).minmax).to eq [1, 4] }
-  if ruby_version_at_least('2.4.1')
-    specify('absence group') { expect(ML.of('(?~abc)').minmax).to eq [0, Float::INFINITY] }
-  end
-
-  specify('raises for missing references') do
-    exp = RP.parse(/(a)\1/).last
-    exp.referenced_expression = nil
-    expect { exp.match_length }.to raise_error(ArgumentError)
-  end
-
-  describe('::of') do
-    it('works with Regexps') { expect(ML.of(/foo/).minmax).to eq [3, 3] }
-    it('works with Strings') { expect(ML.of('foo').minmax).to eq [3, 3] }
-    it('works with Expressions') { expect(ML.of(RP.parse(/foo/)).minmax).to eq [3, 3] }
-  end
-
-  describe('Expression#match_length') do
-    it('returns the MatchLength') { expect(RP.parse(/abc/).match_length.minmax).to eq [3, 3] }
-  end
-
-  describe('Expression#inner_match_length') do
-    it 'returns the MatchLength of an expression that does not count towards parent match_length' do
-      exp = RP.parse(/(?=ab|cdef)/)[0]
-      expect(exp).to be_a Regexp::Expression::Assertion::Base
-      expect(exp.match_length.minmax).to eq [0, 0]
-      expect(exp.inner_match_length.minmax).to eq [2, 4]
-    end
-  end
-
-  describe('#include?') do
-    specify('unquantified') do
-      expect(ML.of(/a/)).to include 1
-      expect(ML.of(/a/)).not_to include 0
-      expect(ML.of(/a/)).not_to include 2
-    end
-
-    specify('fixed quantified') do
-      expect(ML.of(/a{5}/)).to include 5
-      expect(ML.of(/a{5}/)).not_to include 0
-      expect(ML.of(/a{5}/)).not_to include 4
-      expect(ML.of(/a{5}/)).not_to include 6
-    end
-
-    specify('variably quantified') do
-      expect(ML.of(/a?/)).to include 0
-      expect(ML.of(/a?/)).to include 1
-      expect(ML.of(/a?/)).not_to include 2
-    end
-
-    specify('nested quantified') do
-      expect(ML.of(/(a{2}){3,4}/)).to include 6
-      expect(ML.of(/(a{2}){3,4}/)).to include 8
-      expect(ML.of(/(a{2}){3,4}/)).not_to include 0
-      expect(ML.of(/(a{2}){3,4}/)).not_to include 5
-      expect(ML.of(/(a{2}){3,4}/)).not_to include 7
-      expect(ML.of(/(a{2}){3,4}/)).not_to include 9
-    end
-
-    specify('branches') do
-      expect(ML.of(/ab|cdef/)).to include 2
-      expect(ML.of(/ab|cdef/)).to include 4
-      expect(ML.of(/ab|cdef/)).not_to include 0
-      expect(ML.of(/ab|cdef/)).not_to include 3
-      expect(ML.of(/ab|cdef/)).not_to include 5
-    end
-
-    specify('called on leaf node') do
-      expect(ML.of(RP.parse(/a{2}/)[0])).to include 2
-      expect(ML.of(RP.parse(/a{2}/)[0])).not_to include 0
-      expect(ML.of(RP.parse(/a{2}/)[0])).not_to include 1
-      expect(ML.of(RP.parse(/a{2}/)[0])).not_to include 3
-    end
-  end
-
-  describe('#fixed?') do
-    specify('unquantified') { expect(ML.of(/a/)).to be_fixed }
-    specify('fixed quantified') { expect(ML.of(/a{5}/)).to be_fixed }
-    specify('variably quantified') { expect(ML.of(/a?/)).not_to be_fixed }
-    specify('equal branches') { expect(ML.of(/ab|cd/)).to be_fixed }
-    specify('unequal branches') { expect(ML.of(/ab|cdef/)).not_to be_fixed }
-    specify('equal quantified branches') { expect(ML.of(/a{2}|cd/)).to be_fixed }
-    specify('unequal quantified branches') { expect(ML.of(/a{3}|cd/)).not_to be_fixed }
-    specify('empty') { expect(ML.of(//)).to be_fixed }
-  end
-
-  describe('#each') do
-    it 'returns an Enumerator if called without a block' do
-      result = ML.of(/a?/).each
-      expect(result).to be_a(Enumerator)
-      expect(result.next).to eq 0
-      expect(result.next).to eq 1
-      expect { result.next }.to raise_error(StopIteration)
-    end
-
-    it 'is aware of limit option even if called without a block' do
-      result = ML.of(/a?/).each(limit: 1)
-      expect(result).to be_a(Enumerator)
-      expect(result.next).to eq 0
-      expect { result.next }.to raise_error(StopIteration)
-    end
-
-    it 'is limited to 1000 iterations in case there are infinite match lengths' do
-      expect(ML.of(/a*/).first(3000).size).to eq 1000
-    end
-
-    it 'scaffolds the Enumerable interface' do
-      expect(ML.of(/abc|defg/).count).to eq 2
-      expect(ML.of(/(ab)*/).first(5)).to eq [0, 2, 4, 6, 8]
-      expect(ML.of(/a{,10}/).any? { |len| len > 20 }).to be false
-    end
-  end
-
-  describe('#endless_each') do
-    it 'returns an Enumerator if called without a block' do
-      result = ML.of(/a?/).endless_each
-      expect(result).to be_a(Enumerator)
-      expect(result.next).to eq 0
-      expect(result.next).to eq 1
-      expect { result.next }.to raise_error(StopIteration)
-    end
-
-    it 'never stops iterating for infinite match lengths' do
-      expect(ML.of(/a*/).endless_each.first(3000).size).to eq 3000
-    end
-  end
-
-  describe('#inspect') do
-    it 'is nice' do
-      result = RP.parse(/a{2,4}/)[0].match_length
-      expect(result.inspect).to eq '#<Regexp::MatchLength<Literal> min=2 max=4>'
-    end
-  end
-end

data/spec/expression/methods/match_spec.rb

@@ -1,25 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe('Expression#match') do
-  it 'returns the #match result of the respective Regexp' do
-    expect(RP.parse(/a/).match('a')[0]).to eq 'a'
-  end
-
-  it 'can be given an offset, just like Regexp#match' do
-    expect(RP.parse(/./).match('ab', 1)[0]).to eq 'b'
-  end
-
-  it 'works with the #=~ alias' do
-    expect(RP.parse(/a/) =~ 'a').to be_a MatchData
-  end
-end
-
-RSpec.describe('Expression#match?') do
-  it 'returns true if the Respective Regexp matches' do
-    expect(RP.parse(/a/).match?('a')).to be true
-  end
-
-  it 'returns false if the Respective Regexp does not match' do
-    expect(RP.parse(/a/).match?('b')).to be false
-  end
-end

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