regexp_parser 1.5.0 → 1.8.0

data/spec/parser/set/intersections_spec.rb

@@ -2,7 +2,7 @@ require 'spec_helper'
 
 # edge cases with `...-&&...` and `...&&-...` are checked in test_ranges.rb
 
-RSpec.describe('SetIntersection parsing') do
+RSpec.describe('CharacterSet::Intersection parsing') do
   specify('parse set intersection') do
     root = RP.parse('[a&&z]')
     set = root[0]
@@ -22,9 +22,9 @@ RSpec.describe('SetIntersection parsing') do
     expect(seq2.first.to_s).to eq 'z'
     expect(seq2.first).to be_instance_of(Literal)
 
-    expect(set.matches?('a')).to be false
-    expect(set.matches?('&')).to be false
-    expect(set.matches?('z')).to be false
+    expect(set).not_to match 'a'
+    expect(set).not_to match '&'
+    expect(set).not_to match 'z'
   end
 
   specify('parse set intersection range and subset') do
@@ -46,9 +46,9 @@ RSpec.describe('SetIntersection parsing') do
     expect(seq2.first.to_s).to eq '[^a]'
     expect(seq2.first).to be_instance_of(CharacterSet)
 
-    expect(set.matches?('a')).to be false
-    expect(set.matches?('&')).to be false
-    expect(set.matches?('b')).to be true
+    expect(set).not_to match 'a'
+    expect(set).not_to match '&'
+    expect(set).to     match 'b'
   end
 
   specify('parse set intersection trailing range') do
@@ -70,9 +70,9 @@ RSpec.describe('SetIntersection parsing') do
     expect(seq2.first.to_s).to eq 'a-z'
     expect(seq2.first).to be_instance_of(CharacterSet::Range)
 
-    expect(set.matches?('a')).to be true
-    expect(set.matches?('&')).to be false
-    expect(set.matches?('b')).to be false
+    expect(set).to     match 'a'
+    expect(set).not_to match '&'
+    expect(set).not_to match 'b'
   end
 
   specify('parse set intersection type') do
@@ -94,9 +94,9 @@ RSpec.describe('SetIntersection parsing') do
     expect(seq2.first.to_s).to eq '\\w'
     expect(seq2.first).to be_instance_of(CharacterType::Word)
 
-    expect(set.matches?('a')).to be true
-    expect(set.matches?('&')).to be false
-    expect(set.matches?('b')).to be false
+    expect(set).to     match 'a'
+    expect(set).not_to match '&'
+    expect(set).not_to match 'b'
   end
 
   specify('parse set intersection multipart') do
@@ -119,9 +119,9 @@ RSpec.describe('SetIntersection parsing') do
     expect(seq3.count).to eq 3
     expect(seq3.to_s).to eq 'efg'
 
-    expect(set.matches?('e')).to be true
-    expect(set.matches?('f')).to be true
-    expect(set.matches?('a')).to be false
-    expect(set.matches?('g')).to be false
+    expect(set).to     match 'e'
+    expect(set).to     match 'f'
+    expect(set).not_to match 'a'
+    expect(set).not_to match 'g'
   end
 end

data/spec/parser/set/ranges_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-RSpec.describe('SetRang parsing') do
+RSpec.describe('CharacterSet::Range parsing') do
   specify('parse set range') do
     root = RP.parse('[a-z]')
     set = root[0]
@@ -13,7 +13,7 @@ RSpec.describe('SetRang parsing') do
     expect(range.first).to be_instance_of(Literal)
     expect(range.last.to_s).to eq 'z'
     expect(range.last).to be_instance_of(Literal)
-    expect(set.matches?('m')).to be true
+    expect(set).to match 'm'
   end
 
   specify('parse set range hex') do
@@ -28,7 +28,7 @@ RSpec.describe('SetRang parsing') do
     expect(range.first).to be_instance_of(EscapeSequence::Hex)
     expect(range.last.to_s).to eq '\\x99'
     expect(range.last).to be_instance_of(EscapeSequence::Hex)
-    expect(set.matches?('\\x50')).to be true
+    expect(set).to match '\\x50'
   end
 
   specify('parse set range unicode') do
@@ -43,7 +43,7 @@ RSpec.describe('SetRang parsing') do
     expect(range.first).to be_instance_of(EscapeSequence::CodepointList)
     expect(range.last.to_s).to eq '\\u1234'
     expect(range.last).to be_instance_of(EscapeSequence::Codepoint)
-    expect(set.matches?('\\u600')).to be true
+    expect(set).to match '\\u600'
   end
 
   specify('parse set range edge case leading dash') do
@@ -53,7 +53,7 @@ RSpec.describe('SetRang parsing') do
 
     expect(set.count).to eq 1
     expect(range.count).to eq 2
-    expect(set.matches?('a')).to be true
+    expect(set).to match 'a'
   end
 
   specify('parse set range edge case trailing dash') do
@@ -63,7 +63,7 @@ RSpec.describe('SetRang parsing') do
 
     expect(set.count).to eq 1
     expect(range.count).to eq 2
-    expect(set.matches?('$')).to be true
+    expect(set).to match '$'
   end
 
   specify('parse set range edge case leading negate') do
@@ -71,8 +71,8 @@ RSpec.describe('SetRang parsing') do
     set = root[0]
 
     expect(set.count).to eq 2
-    expect(set.matches?('a')).to be true
-    expect(set.matches?('z')).to be false
+    expect(set).to     match 'a'
+    expect(set).not_to match 'z'
   end
 
   specify('parse set range edge case trailing negate') do
@@ -82,7 +82,7 @@ RSpec.describe('SetRang parsing') do
 
     expect(set.count).to eq 1
     expect(range.count).to eq 2
-    expect(set.matches?('$')).to be true
+    expect(set).to match '$'
   end
 
   specify('parse set range edge case leading intersection') do
@@ -91,10 +91,10 @@ RSpec.describe('SetRang parsing') do
 
     expect(set.count).to eq 1
     expect(set.first.last.to_s).to eq '-bc'
-    expect(set.matches?('-')).to be true
-    expect(set.matches?('b')).to be true
-    expect(set.matches?('a')).to be false
-    expect(set.matches?('c')).to be false
+    expect(set).to     match '-'
+    expect(set).to     match 'b'
+    expect(set).not_to match 'a'
+    expect(set).not_to match 'c'
   end
 
   specify('parse set range edge case trailing intersection') do
@@ -103,9 +103,9 @@ RSpec.describe('SetRang parsing') do
 
     expect(set.count).to eq 1
     expect(set.first.first.to_s).to eq 'bc-'
-    expect(set.matches?('-')).to be true
-    expect(set.matches?('b')).to be true
-    expect(set.matches?('a')).to be false
-    expect(set.matches?('c')).to be false
+    expect(set).to     match '-'
+    expect(set).to     match 'b'
+    expect(set).not_to match 'a'
+    expect(set).not_to match 'c'
   end
 end

data/spec/parser/sets_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-RSpec.describe('Set parsing') do
+RSpec.describe('CharacterSet parsing') do
   specify('parse set basic') do
     root = RP.parse('[ab]+')
     exp = root[0]
@@ -39,10 +39,10 @@ RSpec.describe('Set parsing') do
     expect(exp[1]).to be_instance_of(EscapeSequence::Backspace)
     expect(exp[1].text).to eq '\\b'
 
-    expect(exp.matches?('a')).to be true
-    expect(exp.matches?("\b")).to be true
-    expect(exp.matches?('b')).to be false
-    expect(exp.matches?('c')).to be true
+    expect(exp).to     match 'a'
+    expect(exp).to     match "\b"
+    expect(exp).not_to match 'b'
+    expect(exp).to     match 'c'
   end
 
   specify('parse set escape sequence hex') do

data/spec/parser/types_spec.rb

@@ -1,43 +1,18 @@
 require 'spec_helper'
 
-RSpec.describe('Type parsing') do
-  tests = {
-    /a\dc/    => [1, :type,   :digit,     CharacterType::Digit],
-    /a\Dc/    => [1, :type,   :nondigit,  CharacterType::NonDigit],
+RSpec.describe('CharacterType parsing') do
+  include_examples 'parse', /a\dc/,   1 =>  [:type,   :digit,     CharacterType::Digit]
+  include_examples 'parse', /a\Dc/,   1 =>  [:type,   :nondigit,  CharacterType::NonDigit]
 
-    /a\sc/    => [1, :type,   :space,     CharacterType::Space],
-    /a\Sc/    => [1, :type,   :nonspace,  CharacterType::NonSpace],
+  include_examples 'parse', /a\sc/,   1 =>  [:type,   :space,     CharacterType::Space]
+  include_examples 'parse', /a\Sc/,   1 =>  [:type,   :nonspace,  CharacterType::NonSpace]
 
-    /a\hc/    => [1, :type,   :hex,       CharacterType::Hex],
-    /a\Hc/    => [1, :type,   :nonhex,    CharacterType::NonHex],
+  include_examples 'parse', /a\hc/,   1 =>  [:type,   :hex,       CharacterType::Hex]
+  include_examples 'parse', /a\Hc/,   1 =>  [:type,   :nonhex,    CharacterType::NonHex]
 
-    /a\wc/    => [1, :type,   :word,      CharacterType::Word],
-    /a\Wc/    => [1, :type,   :nonword,   CharacterType::NonWord],
-  }
+  include_examples 'parse', /a\wc/,   1 =>  [:type,   :word,      CharacterType::Word]
+  include_examples 'parse', /a\Wc/,   1 =>  [:type,   :nonword,   CharacterType::NonWord]
 
-  tests.each_with_index do |(pattern, (index, type, token, klass)), count|
-    specify("parse_type_#{token}_#{count}") do
-      root = RP.parse(pattern, 'ruby/1.9')
-      exp = root.expressions.at(index)
-
-      expect(exp).to be_a(klass)
-
-      expect(exp.type).to eq type
-      expect(exp.token).to eq token
-    end
-  end
-
-  tests_2_0 = { 'a\\Rc' => [1, :type, :linebreak, CharacterType::Linebreak], 'a\\Xc' => [1, :type, :xgrapheme, CharacterType::ExtendedGrapheme] }
-
-  tests_2_0.each_with_index do |(pattern, (index, type, token, klass)), count|
-    specify("parse_type_#{token}_#{count}") do
-      root = RP.parse(pattern, 'ruby/2.0')
-      exp = root.expressions.at(index)
-
-      expect(exp).to be_a(klass)
-
-      expect(exp.type).to eq type
-      expect(exp.token).to eq token
-    end
-  end
+  include_examples 'parse', 'a\\Rc',  1 =>  [:type,   :linebreak, CharacterType::Linebreak]
+  include_examples 'parse', 'a\\Xc',  1 =>  [:type,   :xgrapheme, CharacterType::ExtendedGrapheme]
 end

data/spec/scanner/anchors_spec.rb

@@ -1,36 +1,21 @@
 require 'spec_helper'
 
 RSpec.describe('Anchor scanning') do
-  tests = {
-   '^abc'       => [0, :anchor,     :bol,                   '^',    0, 1],
-   'abc$'       => [1, :anchor,     :eol,                   '$',    3, 4],
+  include_examples 'scan', '^abc',    0 => [:anchor,  :bol,              '^',    0, 1]
+  include_examples 'scan', 'abc$',    1 => [:anchor,  :eol,              '$',    3, 4]
 
-   '\Aabc'      => [0, :anchor,     :bos,                   '\A',   0, 2],
-   'abc\z'      => [1, :anchor,     :eos,                   '\z',   3, 5],
-   'abc\Z'      => [1, :anchor,     :eos_ob_eol,            '\Z',   3, 5],
+  include_examples 'scan', '\Aabc',   0 => [:anchor,  :bos,              '\A',   0, 2]
+  include_examples 'scan', 'abc\z',   1 => [:anchor,  :eos,              '\z',   3, 5]
+  include_examples 'scan', 'abc\Z',   1 => [:anchor,  :eos_ob_eol,       '\Z',   3, 5]
 
-   'a\bc'       => [1, :anchor,     :word_boundary,         '\b',   1, 3],
-   'a\Bc'       => [1, :anchor,     :nonword_boundary,      '\B',   1, 3],
+  include_examples 'scan', 'a\bc',    1 => [:anchor,  :word_boundary,    '\b',   1, 3]
+  include_examples 'scan', 'a\Bc',    1 => [:anchor,  :nonword_boundary, '\B',   1, 3]
 
-   'a\Gc'       => [1, :anchor,     :match_start,           '\G',   1, 3],
+  include_examples 'scan', 'a\Gc',    1 => [:anchor,  :match_start,      '\G',   1, 3]
 
-   "\\\\Ac"     => [0, :escape,    :backslash,              '\\\\', 0, 2],
-   "a\\\\z"     => [1, :escape,    :backslash,              '\\\\', 1, 3],
-   "a\\\\Z"     => [1, :escape,    :backslash,              '\\\\', 1, 3],
-   "a\\\\bc"    => [1, :escape,    :backslash,              '\\\\', 1, 3],
-   "a\\\\Bc"    => [1, :escape,    :backslash,              '\\\\', 1, 3],
-  }
-
-  tests.each_with_index do |(pattern, (index, type, token, text, ts, te)), count|
-    specify("scanner_#{type}_#{token}_#{count}") do
-      tokens = RS.scan(pattern)
-      result = tokens[index]
-
-      expect(result[0]).to eq type
-      expect(result[1]).to eq token
-      expect(result[2]).to eq text
-      expect(result[3]).to eq ts
-      expect(result[4]).to eq te
-    end
-  end
+  include_examples 'scan', "\\\\Ac",  0 => [:escape, :backslash,         '\\\\', 0, 2]
+  include_examples 'scan', "a\\\\z",  1 => [:escape, :backslash,         '\\\\', 1, 3]
+  include_examples 'scan', "a\\\\Z",  1 => [:escape, :backslash,         '\\\\', 1, 3]
+  include_examples 'scan', "a\\\\bc", 1 => [:escape, :backslash,         '\\\\', 1, 3]
+  include_examples 'scan', "a\\\\Bc", 1 => [:escape, :backslash,         '\\\\', 1, 3]
 end

data/spec/scanner/conditionals_spec.rb

@@ -1,180 +1,128 @@
 require 'spec_helper'
 
 RSpec.describe('Conditional scanning') do
-  tests = {
-    '(a)(?(1)T|F)1'          => [3,  :conditional,  :open,             '(?',  3,  5],
-    '(a)(?(1)T|F)2'          => [4,  :conditional,  :condition_open,   '(',   5,  6],
-    '(a)(?(1)T|F)3'          => [5,  :conditional,  :condition,        '1',   6,  7],
-    '(a)(?(1)T|F)4'          => [6,  :conditional,  :condition_close,  ')',   7,  8],
-    '(a)(?(1)T|F)5'          => [7,  :literal,      :literal,          'T',   8,  9],
-    '(a)(?(1)T|F)6'          => [8,  :conditional,  :separator,        '|',   9,  10],
-    '(a)(?(1)T|F)7'          => [9,  :literal,      :literal,          'F',   10, 11],
-    '(a)(?(1)T|F)8'          => [10, :conditional,  :close,            ')',   11, 12],
-    '(a)(?(1)TRUE)9'         => [8,  :conditional,  :close,            ')',   12, 13],
-    '(a)(?(1)TRUE|)10'       => [8,  :conditional,  :separator,        '|',   12, 13],
-    '(a)(?(1)TRUE|)11'       => [9,  :conditional,  :close,            ')',   13, 14],
-    '(?<N>A)(?(<N>)T|F)1'    => [5,  :conditional,  :condition,        '<N>', 10, 13],
-    "(?'N'A)(?('N')T|F)2"    => [5,  :conditional,  :condition,        "'N'", 10, 13]
-  }
+  include_examples 'scan', /(a)(?(1)T|F)1/,       3  => [:conditional,  :open,            '(?',  3,  5]
+  include_examples 'scan', /(a)(?(1)T|F)2/,       4  => [:conditional,  :condition_open,  '(',   5,  6]
+  include_examples 'scan', /(a)(?(1)T|F)3/,       5  => [:conditional,  :condition,       '1',   6,  7]
+  include_examples 'scan', /(a)(?(1)T|F)4/,       6  => [:conditional,  :condition_close, ')',   7,  8]
+  include_examples 'scan', /(a)(?(1)T|F)5/,       7  => [:literal,      :literal,         'T',   8,  9]
+  include_examples 'scan', /(a)(?(1)T|F)6/,       8  => [:conditional,  :separator,       '|',   9,  10]
+  include_examples 'scan', /(a)(?(1)T|F)7/,       9  => [:literal,      :literal,         'F',   10, 11]
+  include_examples 'scan', /(a)(?(1)T|F)8/,       10 => [:conditional,  :close,           ')',   11, 12]
+  include_examples 'scan', /(a)(?(1)TRUE)9/,      8  => [:conditional,  :close,           ')',   12, 13]
+  include_examples 'scan', /(a)(?(1)TRUE|)10/,    8  => [:conditional,  :separator,       '|',   12, 13]
+  include_examples 'scan', /(a)(?(1)TRUE|)11/,    9  => [:conditional,  :close,           ')',   13, 14]
+  include_examples 'scan', /(?<N>A)(?(<N>)T|F)1/, 5  => [:conditional,  :condition,       '<N>', 10, 13]
+  include_examples 'scan', /(?'N'A)(?('N')T|F)2/, 5  => [:conditional,  :condition,       "'N'", 10, 13]
 
-  tests.each_with_index do |(pattern, (index, type, token, text, ts, te)), count|
-    specify("scanner_#{type}_#{token}_#{count}") do
-      tokens = RS.scan(pattern)
-      result = tokens[index]
+  include_examples 'scan', /(a(b(c)))(?(1)(?(2)d|(?(3)e|f))|(?(2)(?(1)g|h)))/,
+    0  => [:group,        :capture,         '(',   0,  1],
+    1  => [:literal,      :literal,         'a',   1,  2],
+    2  => [:group,        :capture,         '(',   2,  3],
+    3  => [:literal,      :literal,         'b',   3,  4],
+    4  => [:group,        :capture,         '(',   4,  5],
+    5  => [:literal,      :literal,         'c',   5,  6],
+    6  => [:group,        :close,           ')',   6,  7],
+    7  => [:group,        :close,           ')',   7,  8],
+    8  => [:group,        :close,           ')',   8,  9],
+    9  => [:conditional,  :open,            '(?',  9, 11],
+    10 => [:conditional,  :condition_open,  '(',  11, 12],
+    11 => [:conditional,  :condition,       '1',  12, 13],
+    12 => [:conditional,  :condition_close, ')',  13, 14],
+    13 => [:conditional,  :open,            '(?', 14, 16],
+    14 => [:conditional,  :condition_open,  '(',  16, 17],
+    15 => [:conditional,  :condition,       '2',  17, 18],
+    16 => [:conditional,  :condition_close, ')',  18, 19],
+    17 => [:literal,      :literal,         'd',  19, 20],
+    18 => [:conditional,  :separator,       '|',  20, 21],
+    19 => [:conditional,  :open,            '(?', 21, 23],
+    20 => [:conditional,  :condition_open,  '(',  23, 24],
+    21 => [:conditional,  :condition,       '3',  24, 25],
+    22 => [:conditional,  :condition_close, ')',  25, 26],
+    23 => [:literal,      :literal,         'e',  26, 27],
+    24 => [:conditional,  :separator,       '|',  27, 28],
+    25 => [:literal,      :literal,         'f',  28, 29],
+    26 => [:conditional,  :close,           ')',  29, 30],
+    27 => [:conditional,  :close,           ')',  30, 31],
+    28 => [:conditional,  :separator,       '|',  31, 32],
+    29 => [:conditional,  :open,            '(?', 32, 34],
+    30 => [:conditional,  :condition_open,  '(',  34, 35],
+    31 => [:conditional,  :condition,       '2',  35, 36],
+    32 => [:conditional,  :condition_close, ')',  36, 37],
+    33 => [:conditional,  :open,            '(?', 37, 39],
+    34 => [:conditional,  :condition_open,  '(',  39, 40],
+    35 => [:conditional,  :condition,       '1',  40, 41],
+    36 => [:conditional,  :condition_close, ')',  41, 42],
+    37 => [:literal,      :literal,         'g',  42, 43],
+    38 => [:conditional,  :separator,       '|',  43, 44],
+    39 => [:literal,      :literal,         'h',  44, 45],
+    40 => [:conditional,  :close,           ')',  45, 46],
+    41 => [:conditional,  :close,           ')',  46, 47],
+    42 => [:conditional,  :close,           ')',  47, 48]
 
-      expect(result[0]).to eq type
-      expect(result[1]).to eq token
-      expect(result[2]).to eq text
-      expect(result[3]).to eq ts
-      expect(result[4]).to eq te
-    end
-  end
+  include_examples 'scan', /((a)|(b)|((?(2)(c(d|e)+)?|(?(3)f|(?(4)(g|(h)(i)))))))/,
+    0  => [:group,        :capture,         '(',   0,  1],
+    1  => [:group,        :capture,         '(',   1,  2],
+    2  => [:literal,      :literal,         'a',   2,  3],
+    3  => [:group,        :close,           ')',   3,  4],
+    4  => [:meta,         :alternation,     '|',   4,  5],
+    5  => [:group,        :capture,         '(',   5,  6],
+    6  => [:literal,      :literal,         'b',   6,  7],
+    7  => [:group,        :close,           ')',   7,  8],
+    8  => [:meta,         :alternation,     '|',   8,  9],
+    9  => [:group,        :capture,         '(',   9, 10],
+    10 => [:conditional,  :open,            '(?', 10, 12],
+    11 => [:conditional,  :condition_open,  '(',  12, 13],
+    12 => [:conditional,  :condition,       '2',  13, 14],
+    13 => [:conditional,  :condition_close, ')',  14, 15],
+    14 => [:group,        :capture,         '(',  15, 16],
+    15 => [:literal,      :literal,         'c',  16, 17],
+    16 => [:group,        :capture,         '(',  17, 18],
+    17 => [:literal,      :literal,         'd',  18, 19],
+    18 => [:meta,         :alternation,     '|',  19, 20],
+    19 => [:literal,      :literal,         'e',  20, 21],
+    20 => [:group,        :close,           ')',  21, 22],
+    21 => [:quantifier,   :one_or_more,     '+',  22, 23],
+    22 => [:group,        :close,           ')',  23, 24],
+    23 => [:quantifier,   :zero_or_one,     '?',  24, 25],
+    24 => [:conditional,  :separator,       '|',  25, 26],
+    25 => [:conditional,  :open,            '(?', 26, 28],
+    26 => [:conditional,  :condition_open,  '(',  28, 29],
+    27 => [:conditional,  :condition,       '3',  29, 30],
+    28 => [:conditional,  :condition_close, ')',  30, 31],
+    29 => [:literal,      :literal,         'f',  31, 32],
+    30 => [:conditional,  :separator,       '|',  32, 33],
+    31 => [:conditional,  :open,            '(?', 33, 35],
+    32 => [:conditional,  :condition_open,  '(',  35, 36],
+    33 => [:conditional,  :condition,       '4',  36, 37],
+    34 => [:conditional,  :condition_close, ')',  37, 38],
+    35 => [:group,        :capture,         '(',  38, 39],
+    36 => [:literal,      :literal,         'g',  39, 40],
+    37 => [:meta,         :alternation,     '|',  40, 41],
+    38 => [:group,        :capture,         '(',  41, 42],
+    39 => [:literal,      :literal,         'h',  42, 43],
+    40 => [:group,        :close,           ')',  43, 44],
+    41 => [:group,        :capture,         '(',  44, 45],
+    42 => [:literal,      :literal,         'i',  45, 46],
+    43 => [:group,        :close,           ')',  46, 47],
+    44 => [:group,        :close,           ')',  47, 48],
+    45 => [:conditional,  :close,           ')',  48, 49],
+    46 => [:conditional,  :close,           ')',  49, 50],
+    47 => [:conditional,  :close,           ')',  50, 51],
+    48 => [:group,        :close,           ')',  51, 52],
+    49 => [:group,        :close,           ')',  52, 53]
 
-  specify('scan conditional nested') do
-    regexp = '(a(b(c)))(?(1)(?(2)d|(?(3)e|f))|(?(2)(?(1)g|h)))'
-    tokens = RS.scan(regexp)
-
-    [
-      [ 0, :group,        :capture,         '(',   0,  1],
-      [ 1, :literal,      :literal,         'a',   1,  2],
-      [ 2, :group,        :capture,         '(',   2,  3],
-      [ 3, :literal,      :literal,         'b',   3,  4],
-      [ 4, :group,        :capture,         '(',   4,  5],
-      [ 5, :literal,      :literal,         'c',   5,  6],
-      [ 6, :group,        :close,           ')',   6,  7],
-      [ 7, :group,        :close,           ')',   7,  8],
-      [ 8, :group,        :close,           ')',   8,  9],
-      [ 9, :conditional,  :open,            '(?',  9, 11],
-      [10, :conditional,  :condition_open,  '(',  11, 12],
-      [11, :conditional,  :condition,       '1',  12, 13],
-      [12, :conditional,  :condition_close, ')',  13, 14],
-      [13, :conditional,  :open,            '(?', 14, 16],
-      [14, :conditional,  :condition_open,  '(',  16, 17],
-      [15, :conditional,  :condition,       '2',  17, 18],
-      [16, :conditional,  :condition_close, ')',  18, 19],
-      [17, :literal,      :literal,         'd',  19, 20],
-      [18, :conditional,  :separator,       '|',  20, 21],
-      [19, :conditional,  :open,            '(?', 21, 23],
-      [20, :conditional,  :condition_open,  '(',  23, 24],
-      [21, :conditional,  :condition,       '3',  24, 25],
-      [22, :conditional,  :condition_close, ')',  25, 26],
-      [23, :literal,      :literal,         'e',  26, 27],
-      [24, :conditional,  :separator,       '|',  27, 28],
-      [25, :literal,      :literal,         'f',  28, 29],
-      [26, :conditional,  :close,           ')',  29, 30],
-      [27, :conditional,  :close,           ')',  30, 31],
-      [28, :conditional,  :separator,       '|',  31, 32],
-      [29, :conditional,  :open,            '(?', 32, 34],
-      [30, :conditional,  :condition_open,  '(',  34, 35],
-      [31, :conditional,  :condition,       '2',  35, 36],
-      [32, :conditional,  :condition_close, ')',  36, 37],
-      [33, :conditional,  :open,            '(?', 37, 39],
-      [34, :conditional,  :condition_open,  '(',  39, 40],
-      [35, :conditional,  :condition,       '1',  40, 41],
-      [36, :conditional,  :condition_close, ')',  41, 42],
-      [37, :literal,      :literal,         'g',  42, 43],
-      [38, :conditional,  :separator,       '|',  43, 44],
-      [39, :literal,      :literal,         'h',  44, 45],
-      [40, :conditional,  :close,           ')',  45, 46],
-      [41, :conditional,  :close,           ')',  46, 47],
-      [42, :conditional,  :close,           ')',  47, 48]
-    ].each do |index, type, token, text, ts, te|
-      result = tokens[index]
-
-      expect(result[0]).to eq type
-      expect(result[1]).to eq token
-      expect(result[2]).to eq text
-      expect(result[3]).to eq ts
-      expect(result[4]).to eq te
-    end
-  end
-
-  specify('scan conditional nested groups') do
-    regexp = '((a)|(b)|((?(2)(c(d|e)+)?|(?(3)f|(?(4)(g|(h)(i)))))))'
-    tokens = RS.scan(regexp)
-
-    [
-      [ 0, :group,        :capture,         '(',   0,  1],
-      [ 1, :group,        :capture,         '(',   1,  2],
-      [ 2, :literal,      :literal,         'a',   2,  3],
-      [ 3, :group,        :close,           ')',   3,  4],
-      [ 4, :meta,         :alternation,     '|',   4,  5],
-      [ 5, :group,        :capture,         '(',   5,  6],
-      [ 6, :literal,      :literal,         'b',   6,  7],
-      [ 7, :group,        :close,           ')',   7,  8],
-      [ 8, :meta,         :alternation,     '|',   8,  9],
-      [ 9, :group,        :capture,         '(',   9, 10],
-      [10, :conditional,  :open,            '(?', 10, 12],
-      [11, :conditional,  :condition_open,  '(',  12, 13],
-      [12, :conditional,  :condition,       '2',  13, 14],
-      [13, :conditional,  :condition_close, ')',  14, 15],
-      [14, :group,        :capture,         '(',  15, 16],
-      [15, :literal,      :literal,         'c',  16, 17],
-      [16, :group,        :capture,         '(',  17, 18],
-      [17, :literal,      :literal,         'd',  18, 19],
-      [18, :meta,         :alternation,     '|',  19, 20],
-      [19, :literal,      :literal,         'e',  20, 21],
-      [20, :group,        :close,           ')',  21, 22],
-      [21, :quantifier,   :one_or_more,     '+',  22, 23],
-      [22, :group,        :close,           ')',  23, 24],
-      [23, :quantifier,   :zero_or_one,     '?',  24, 25],
-      [24, :conditional,  :separator,       '|',  25, 26],
-      [25, :conditional,  :open,            '(?', 26, 28],
-      [26, :conditional,  :condition_open,  '(',  28, 29],
-      [27, :conditional,  :condition,       '3',  29, 30],
-      [28, :conditional,  :condition_close, ')',  30, 31],
-      [29, :literal,      :literal,         'f',  31, 32],
-      [30, :conditional,  :separator,       '|',  32, 33],
-      [31, :conditional,  :open,            '(?', 33, 35],
-      [32, :conditional,  :condition_open,  '(',  35, 36],
-      [33, :conditional,  :condition,       '4',  36, 37],
-      [34, :conditional,  :condition_close, ')',  37, 38],
-      [35, :group,        :capture,         '(',  38, 39],
-      [36, :literal,      :literal,         'g',  39, 40],
-      [37, :meta,         :alternation,     '|',  40, 41],
-      [38, :group,        :capture,         '(',  41, 42],
-      [39, :literal,      :literal,         'h',  42, 43],
-      [40, :group,        :close,           ')',  43, 44],
-      [41, :group,        :capture,         '(',  44, 45],
-      [42, :literal,      :literal,         'i',  45, 46],
-      [43, :group,        :close,           ')',  46, 47],
-      [44, :group,        :close,           ')',  47, 48],
-      [45, :conditional,  :close,           ')',  48, 49],
-      [46, :conditional,  :close,           ')',  49, 50],
-      [47, :conditional,  :close,           ')',  50, 51],
-      [48, :group,        :close,           ')',  51, 52],
-      [49, :group,        :close,           ')',  52, 53]
-    ].each do |index, type, token, text, ts, te|
-      result = tokens[index]
-
-      expect(result[0]).to eq type
-      expect(result[1]).to eq token
-      expect(result[2]).to eq text
-      expect(result[3]).to eq ts
-      expect(result[4]).to eq te
-    end
-  end
-
-  specify('scan conditional nested alternation') do
-    regexp = '(a)(?(1)(b|c|d)|(e|f|g))(h)(?(2)(i|j|k)|(l|m|n))|o|p'
-    tokens = RS.scan(regexp)
-
-    [9, 11, 17, 19, 32, 34, 40, 42, 46, 48].each do |index|
-      result = tokens[index]
-
-      expect(result[0]).to eq :meta
-      expect(result[1]).to eq :alternation
-      expect(result[2]).to eq '|'
-      expect((result[4] - result[3])).to eq 1
-    end
-
-    [14, 37].each do |index|
-      result = tokens[index]
-
-      expect(result[0]).to eq :conditional
-      expect(result[1]).to eq :separator
-      expect(result[2]).to eq '|'
-      expect((result[4] - result[3])).to eq 1
-    end
-  end
+  include_examples 'scan', /(a)(?(1)(b|c|d)|(e|f|g))(h)(?(2)(i|j|k)|(l|m|n))|o|p/,
+    9  => [:meta,        :alternation, '|', 10, 11],
+    11 => [:meta,        :alternation, '|', 12, 13],
+    14 => [:conditional, :separator,   '|', 15, 16],
+    17 => [:meta,        :alternation, '|', 18, 19],
+    19 => [:meta,        :alternation, '|', 20, 21],
+    32 => [:meta,        :alternation, '|', 34, 35],
+    34 => [:meta,        :alternation, '|', 36, 37],
+    37 => [:conditional, :separator,   '|', 39, 40],
+    40 => [:meta,        :alternation, '|', 42, 43],
+    42 => [:meta,        :alternation, '|', 44, 45],
+    46 => [:meta,        :alternation, '|', 48, 49],
+    48 => [:meta,        :alternation, '|', 50, 51]
 end