regexp_parser 1.5.0 → 1.8.0

data/spec/scanner/delimiters_spec.rb

@@ -0,0 +1,52 @@
+require 'spec_helper'
+
+RSpec.describe('Literal delimiter scanning') do
+  include_examples 'scan', '}',
+    0 => [:literal,     :literal,       '}',        0,  1]
+
+  include_examples 'scan', '}}',
+    0 => [:literal,     :literal,       '}}',       0,  2]
+
+  include_examples 'scan', '{',
+    0 => [:literal,     :literal,       '{',        0,  1]
+
+  include_examples 'scan', '{{',
+    0 => [:literal,     :literal,       '{{',       0,  2]
+
+  include_examples 'scan', '{}',
+    0 => [:literal,     :literal,       '{}',       0,  2]
+
+  include_examples 'scan', '}{',
+    0 => [:literal,     :literal,       '}{',       0,  2]
+
+  include_examples 'scan', '}{+',
+    0 => [:literal,     :literal,       '}{',       0,  2]
+
+  include_examples 'scan', '{{var}}',
+    0 => [:literal,     :literal,       '{{var}}',  0,  7]
+
+  include_examples 'scan', 'a{1,2',
+    0 => [:literal,     :literal,       'a{1,2',    0,  5]
+
+  include_examples 'scan', '({.+})',
+    0 => [:group,       :capture,       '(',        0,  1],
+    1 => [:literal,     :literal,       '{',        1,  2],
+    2 => [:meta,        :dot,           '.',        2,  3],
+    3 => [:quantifier,  :one_or_more,   '+',        3,  4],
+    4 => [:literal,     :literal,       '}',        4,  5],
+    5 => [:group,       :close,         ')',        5,  6]
+
+  include_examples 'scan', ']',
+    0 => [:literal,     :literal,       ']',        0,  1]
+
+  include_examples 'scan', ']]',
+    0 => [:literal,     :literal,       ']]',       0,  2]
+
+  include_examples 'scan', ']\[',
+    0 => [:literal,     :literal,       ']',        0,  1],
+    1 => [:escape,      :set_open,      '\[',       1,  3]
+
+  include_examples 'scan', '()',
+    0 => [:group,       :capture,       '(',        0,  1],
+    1 => [:group,       :close,         ')',        1,  2]
+end

data/spec/scanner/errors_spec.rb

@@ -1,90 +1,67 @@
 require 'spec_helper'
 
-RSpec.describe('Scanning errors') do
-  specify('scanner unbalanced set') do
-    expect { RS.scan('[[:alpha:]') }.to raise_error(RS::PrematureEndError)
-  end
-
-  specify('scanner unbalanced group') do
-    expect { RS.scan('(abc') }.to raise_error(RS::PrematureEndError)
-  end
-
-  specify('scanner unbalanced interval') do
-    expect { RS.scan('a{1,2') }.to raise_error(RS::PrematureEndError)
-  end
-
-  specify('scanner eof in property') do
-    expect { RS.scan('\\p{asci') }.to raise_error(RS::PrematureEndError)
-  end
-
-  specify('scanner incomplete property') do
-    expect { RS.scan('\\p{ascii abc') }.to raise_error(RS::PrematureEndError)
-  end
-
-  specify('scanner unknown property') do
-    expect { RS.scan('\\p{foobar}') }.to raise_error(RS::UnknownUnicodePropertyError)
-  end
-
-  specify('scanner incomplete options') do
-    expect { RS.scan('(?mix abc)') }.to raise_error(RS::ScannerError)
-  end
-
-  specify('scanner eof options') do
-    expect { RS.scan('(?mix') }.to raise_error(RS::PrematureEndError)
-  end
-
-  specify('scanner incorrect options') do
-    expect { RS.scan('(?mix^bc') }.to raise_error(RS::ScannerError)
-  end
-
-  specify('scanner eof escape') do
-    expect { RS.scan('\\') }.to raise_error(RS::PrematureEndError)
-  end
-
-  specify('scanner eof in hex escape') do
-    expect { RS.scan('\\x') }.to raise_error(RS::PrematureEndError)
-  end
-
-  specify('scanner eof in codepoint escape') do
-    expect { RS.scan('\\u') }.to raise_error(RS::PrematureEndError)
-    expect { RS.scan('\\u0') }.to raise_error(RS::PrematureEndError)
-    expect { RS.scan('\\u00') }.to raise_error(RS::PrematureEndError)
-    expect { RS.scan('\\u000') }.to raise_error(RS::PrematureEndError)
-    expect { RS.scan('\\u{') }.to raise_error(RS::PrematureEndError)
-    expect { RS.scan('\\u{00') }.to raise_error(RS::PrematureEndError)
-    expect { RS.scan('\\u{0000') }.to raise_error(RS::PrematureEndError)
-    expect { RS.scan('\\u{0000 ') }.to raise_error(RS::PrematureEndError)
-    expect { RS.scan('\\u{0000 0000') }.to raise_error(RS::PrematureEndError)
-  end
-
-  specify('scanner eof in control sequence') do
-    expect { RS.scan('\\c') }.to raise_error(RS::PrematureEndError)
-    expect { RS.scan('\\c\\M') }.to raise_error(RS::PrematureEndError)
-    expect { RS.scan('\\c\\M-') }.to raise_error(RS::PrematureEndError)
-    expect { RS.scan('\\C') }.to raise_error(RS::PrematureEndError)
-    expect { RS.scan('\\C-') }.to raise_error(RS::PrematureEndError)
-    expect { RS.scan('\\C-\\M') }.to raise_error(RS::PrematureEndError)
-    expect { RS.scan('\\C-\\M-') }.to raise_error(RS::PrematureEndError)
-  end
-
-  specify('scanner eof in meta sequence') do
-    expect { RS.scan('\\M') }.to raise_error(RS::PrematureEndError)
-    expect { RS.scan('\\M-') }.to raise_error(RS::PrematureEndError)
-    expect { RS.scan('\\M-\\') }.to raise_error(RS::PrematureEndError)
-    expect { RS.scan('\\M-\\c') }.to raise_error(RS::PrematureEndError)
-    expect { RS.scan('\\M-\\C') }.to raise_error(RS::PrematureEndError)
-    expect { RS.scan('\\M-\\C-') }.to raise_error(RS::PrematureEndError)
-  end
-
-  specify('scanner invalid hex escape') do
-    expect { RS.scan('\\xZ') }.to raise_error(RS::InvalidSequenceError)
-    expect { RS.scan('\\xZ0') }.to raise_error(RS::InvalidSequenceError)
-  end
-
-  specify('scanner invalid named group') do
-    expect { RS.scan("(?'')") }.to raise_error(RS::InvalidGroupError)
-    expect { RS.scan("(?''empty-name)") }.to raise_error(RS::InvalidGroupError)
-    expect { RS.scan('(?<>)') }.to raise_error(RS::InvalidGroupError)
-    expect { RS.scan('(?<>empty-name)') }.to raise_error(RS::InvalidGroupError)
-  end
+RSpec.describe(Regexp::Scanner) do
+  RSpec.shared_examples 'scan error' do |error, issue, source|
+    it "raises #{error} for #{issue} `#{source}`" do
+      expect { RS.scan(source) }.to raise_error(error)
+    end
+  end
+
+  include_examples 'scan error', RS::PrematureEndError, 'unbalanced set', '[a'
+  include_examples 'scan error', RS::PrematureEndError, 'unbalanced set', '[[:alpha:]'
+  include_examples 'scan error', RS::PrematureEndError, 'unbalanced group', '(abc'
+  include_examples 'scan error', RS::PrematureEndError, 'eof in property', '\p{asci'
+  include_examples 'scan error', RS::PrematureEndError, 'incomplete property', '\p{ascii abc'
+  include_examples 'scan error', RS::PrematureEndError, 'eof options', '(?mix'
+  include_examples 'scan error', RS::PrematureEndError, 'eof escape', '\\'
+  include_examples 'scan error', RS::PrematureEndError, 'eof in hex escape', '\x'
+  include_examples 'scan error', RS::PrematureEndError, 'eof in cp escape', '\u'
+  include_examples 'scan error', RS::PrematureEndError, 'eof in cp escape', '\u0'
+  include_examples 'scan error', RS::PrematureEndError, 'eof in cp escape', '\u00'
+  include_examples 'scan error', RS::PrematureEndError, 'eof in cp escape', '\u000'
+  include_examples 'scan error', RS::PrematureEndError, 'eof in cp escape', '\u{'
+  include_examples 'scan error', RS::PrematureEndError, 'eof in cp escape', '\u{00'
+  include_examples 'scan error', RS::PrematureEndError, 'eof in cp escape', '\u{0000'
+  include_examples 'scan error', RS::PrematureEndError, 'eof in cp escape', '\u{0000 '
+  include_examples 'scan error', RS::PrematureEndError, 'eof in cp escape', '\u{0000 0000'
+  include_examples 'scan error', RS::PrematureEndError, 'eof in c-seq', '\c'
+  include_examples 'scan error', RS::PrematureEndError, 'eof in c-seq', '\c\M'
+  include_examples 'scan error', RS::PrematureEndError, 'eof in c-seq', '\c\M-'
+  include_examples 'scan error', RS::PrematureEndError, 'eof in c-seq', '\C'
+  include_examples 'scan error', RS::PrematureEndError, 'eof in c-seq', '\C-'
+  include_examples 'scan error', RS::PrematureEndError, 'eof in c-seq', '\C-\M'
+  include_examples 'scan error', RS::PrematureEndError, 'eof in c-seq', '\C-\M-'
+  include_examples 'scan error', RS::PrematureEndError, 'eof in m-seq', '\M'
+  include_examples 'scan error', RS::PrematureEndError, 'eof in m-seq', '\M-'
+  include_examples 'scan error', RS::PrematureEndError, 'eof in m-seq', '\M-\\'
+  include_examples 'scan error', RS::PrematureEndError, 'eof in m-seq', '\M-\c'
+  include_examples 'scan error', RS::PrematureEndError, 'eof in m-seq', '\M-\C'
+  include_examples 'scan error', RS::PrematureEndError, 'eof in m-seq', '\M-\C-'
+  include_examples 'scan error', RS::InvalidSequenceError, 'invalid hex', '\xZ'
+  include_examples 'scan error', RS::InvalidSequenceError, 'invalid hex', '\xZ0'
+  include_examples 'scan error', RS::InvalidSequenceError, 'invalid c-seq', '\cü'
+  include_examples 'scan error', RS::InvalidSequenceError, 'invalid c-seq', '\c\M-ü'
+  include_examples 'scan error', RS::InvalidSequenceError, 'invalid c-seq', '\C-ü'
+  include_examples 'scan error', RS::InvalidSequenceError, 'invalid c-seq', '\C-\M-ü'
+  include_examples 'scan error', RS::InvalidSequenceError, 'invalid m-seq', '\M-ü'
+  include_examples 'scan error', RS::InvalidSequenceError, 'invalid m-seq', '\M-\cü'
+  include_examples 'scan error', RS::InvalidSequenceError, 'invalid m-seq', '\M-\C-ü'
+  include_examples 'scan error', RS::ScannerError, 'invalid c-seq', '\Ca'
+  include_examples 'scan error', RS::ScannerError, 'invalid m-seq', '\Ma'
+  include_examples 'scan error', RS::InvalidGroupError, 'invalid group', "(?'')"
+  include_examples 'scan error', RS::InvalidGroupError, 'invalid group', "(?''empty-name)"
+  include_examples 'scan error', RS::InvalidGroupError, 'invalid group', '(?<>)'
+  include_examples 'scan error', RS::InvalidGroupError, 'invalid group', '(?<>empty-name)'
+  include_examples 'scan error', RS::InvalidGroupOption, 'invalid option', '(?foo)'
+  include_examples 'scan error', RS::InvalidGroupOption, 'invalid option', '(?mix abc)'
+  include_examples 'scan error', RS::InvalidGroupOption, 'invalid option', '(?mix^bc'
+  include_examples 'scan error', RS::InvalidGroupOption, 'invalid option', '(?)'
+  include_examples 'scan error', RS::InvalidGroupOption, 'invalid neg option', '(?-foo)'
+  include_examples 'scan error', RS::InvalidGroupOption, 'invalid neg option', '(?-u)'
+  include_examples 'scan error', RS::InvalidGroupOption, 'invalid neg option', '(?-mixu)'
+  include_examples 'scan error', RS::InvalidBackrefError, 'empty backref', '\k<>'
+  include_examples 'scan error', RS::InvalidBackrefError, 'empty backref', '\k\'\''
+  include_examples 'scan error', RS::InvalidBackrefError, 'empty refcall', '\g<>'
+  include_examples 'scan error', RS::InvalidBackrefError, 'empty refcall', '\g\'\''
+  include_examples 'scan error', RS::UnknownUnicodePropertyError, 'unknown property', '\p{foobar}'
 end

data/spec/scanner/escapes_spec.rb

@@ -1,54 +1,57 @@
 require 'spec_helper'
 
 RSpec.describe('Escape scanning') do
-  tests = {
-    /c\at/            => [1, :escape,  :bell,             '\a',             1,  3],
-
-    # not an escape outside a character set
-    /c\bt/            => [1, :anchor,  :word_boundary,    '\b',             1, 3],
-
-    /c\ft/            => [1, :escape,  :form_feed,        '\f',             1,  3],
-    /c\nt/            => [1, :escape,  :newline,          '\n',             1,  3],
-    /c\tt/            => [1, :escape,  :tab,              '\t',             1,  3],
-    /c\vt/            => [1, :escape,  :vertical_tab,     '\v',             1,  3],
-
-    'c\qt'            => [1, :escape,  :literal,          '\q',             1,  3],
-
-    'a\012c'          => [1, :escape,  :octal,            '\012',           1,  5],
-    'a\0124'          => [1, :escape,  :octal,            '\012',           1,  5],
-    '\712+7'          => [0, :escape,  :octal,            '\712',           0,  4],
-
-    'a\x24c'          => [1, :escape,  :hex,              '\x24',           1,  5],
-    'a\x0640c'        => [1, :escape,  :hex,              '\x06',           1,  5],
-
-    'a\u0640c'        => [1, :escape,  :codepoint,        '\u0640',         1,  7],
-    'a\u{640 0641}c'  => [1, :escape,  :codepoint_list,   '\u{640 0641}',   1,  13],
-    'a\u{10FFFF}c'    => [1, :escape,  :codepoint_list,   '\u{10FFFF}',     1,  11],
-
-    /a\cBc/           => [1, :escape,  :control,          '\cB',            1,  4],
-    /a\C-bc/          => [1, :escape,  :control,          '\C-b',           1,  5],
-    /a\c\M-Bc/n       => [1, :escape,  :control,          '\c\M-B',         1,  7],
-    /a\C-\M-Bc/n      => [1, :escape,  :control,          '\C-\M-B',        1,  8],
-
-    /a\M-Bc/n         => [1, :escape,  :meta_sequence,    '\M-B',           1,  5],
-    /a\M-\C-Bc/n      => [1, :escape,  :meta_sequence,    '\M-\C-B',        1,  8],
-    /a\M-\cBc/n       => [1, :escape,  :meta_sequence,    '\M-\cB',         1,  7],
-
-    'ab\\\xcd'        => [1, :escape,  :backslash,        '\\\\',           2,  4],
-    'ab\\\0cd'        => [1, :escape,  :backslash,        '\\\\',           2,  4],
-    'ab\\\Kcd'        => [1, :escape,  :backslash,        '\\\\',           2,  4],
-  }
-
-  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.at(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', /c\at/,            1 => [:escape,  :bell,             '\a',             1,  3]
+
+  # not an escape outside a character set
+  include_examples 'scan', /c\bt/,            1 => [:anchor,  :word_boundary,    '\b',             1, 3]
+
+  include_examples 'scan', /c\ft/,            1 => [:escape,  :form_feed,        '\f',             1,  3]
+  include_examples 'scan', /c\nt/,            1 => [:escape,  :newline,          '\n',             1,  3]
+  include_examples 'scan', /c\tt/,            1 => [:escape,  :tab,              '\t',             1,  3]
+  include_examples 'scan', /c\vt/,            1 => [:escape,  :vertical_tab,     '\v',             1,  3]
+
+  include_examples 'scan', 'c\qt',            1 => [:escape,  :literal,          '\q',             1,  3]
+
+  # these incomplete ref/call sequences are treated as literal escapes by Ruby
+  include_examples 'scan', 'c\gt',            1 => [:escape,  :literal,          '\g',             1,  3]
+  include_examples 'scan', 'c\kt',            1 => [:escape,  :literal,          '\k',             1,  3]
+
+  include_examples 'scan', 'a\012c',          1 => [:escape,  :octal,            '\012',           1,  5]
+  include_examples 'scan', 'a\0124',          1 => [:escape,  :octal,            '\012',           1,  5]
+  include_examples 'scan', '\712+7',          0 => [:escape,  :octal,            '\712',           0,  4]
+
+  include_examples 'scan', 'a\x24c',          1 => [:escape,  :hex,              '\x24',           1,  5]
+  include_examples 'scan', 'a\x0640c',        1 => [:escape,  :hex,              '\x06',           1,  5]
+
+  include_examples 'scan', 'a\u0640c',        1 => [:escape,  :codepoint,        '\u0640',         1,  7]
+  include_examples 'scan', 'a\u{640 0641}c',  1 => [:escape,  :codepoint_list,   '\u{640 0641}',   1,  13]
+  include_examples 'scan', 'a\u{10FFFF}c',    1 => [:escape,  :codepoint_list,   '\u{10FFFF}',     1,  11]
+
+  include_examples 'scan', /a\cBc/,           1 => [:escape,  :control,          '\cB',            1,  4]
+  include_examples 'scan', /a\c^c/,           1 => [:escape,  :control,          '\c^',            1,  4]
+  include_examples 'scan', /a\c\n/,           1 => [:escape,  :control,          '\c\n',           1,  5]
+  include_examples 'scan', /a\c\\b/,          1 => [:escape,  :control,          '\c\\\\',         1,  5]
+  include_examples 'scan', /a\C-bc/,          1 => [:escape,  :control,          '\C-b',           1,  5]
+  include_examples 'scan', /a\C-^b/,          1 => [:escape,  :control,          '\C-^',           1,  5]
+  include_examples 'scan', /a\C-\nb/,         1 => [:escape,  :control,          '\C-\n',          1,  6]
+  include_examples 'scan', /a\C-\\b/,         1 => [:escape,  :control,          '\C-\\\\',        1,  6]
+  include_examples 'scan', /a\c\M-Bc/n,       1 => [:escape,  :control,          '\c\M-B',         1,  7]
+  include_examples 'scan', /a\C-\M-Bc/n,      1 => [:escape,  :control,          '\C-\M-B',        1,  8]
+
+  include_examples 'scan', /a\M-Bc/n,         1 => [:escape,  :meta_sequence,    '\M-B',           1,  5]
+  include_examples 'scan', /a\M-\cBc/n,       1 => [:escape,  :meta_sequence,    '\M-\cB',         1,  7]
+  include_examples 'scan', /a\M-\c^/n,        1 => [:escape,  :meta_sequence,    '\M-\c^',         1,  7]
+  include_examples 'scan', /a\M-\c\n/n,       1 => [:escape,  :meta_sequence,    '\M-\c\n',        1,  8]
+  include_examples 'scan', /a\M-\c\\/n,       1 => [:escape,  :meta_sequence,    '\M-\c\\\\',      1,  8]
+  include_examples 'scan', /a\M-\C-Bc/n,      1 => [:escape,  :meta_sequence,    '\M-\C-B',        1,  8]
+  include_examples 'scan', /a\M-\C-\\/n,      1 => [:escape,  :meta_sequence,    '\M-\C-\\\\',     1,  9]
+
+  include_examples 'scan', 'ab\\\xcd',        1 => [:escape,  :backslash,        '\\\\',           2,  4]
+  include_examples 'scan', 'ab\\\0cd',        1 => [:escape,  :backslash,        '\\\\',           2,  4]
+  include_examples 'scan', 'ab\\\Kcd',        1 => [:escape,  :backslash,        '\\\\',           2,  4]
+
+  include_examples 'scan', 'ab\^cd',          1 => [:escape,  :bol,              '\^',             2,  4]
+  include_examples 'scan', 'ab\$cd',          1 => [:escape,  :eol,              '\$',             2,  4]
+  include_examples 'scan', 'ab\[cd',          1 => [:escape,  :set_open,         '\[',             2,  4]
 end

data/spec/scanner/free_space_spec.rb

@@ -1,196 +1,133 @@
 require 'spec_helper'
 
 RSpec.describe('FreeSpace scanning') do
-  specify('scan free space tokens') do
-    regexp = /
+  describe('scan free space tokens') do
+    let(:tokens) { RS.scan(/
       a
       b  ?  c  *
       d  {2,3}
       e + | f +
-    /x
+    /x) }
 
-    tokens = RS.scan(regexp)
-
-    0.upto(24) do |i|
-      if i.even?
+    0.upto(24).select(&:even?).each do |i|
+      it "scans #{i} as free space" do
         expect(tokens[i][0]).to eq :free_space
         expect(tokens[i][1]).to eq :whitespace
-      else
+      end
+    end
+    0.upto(24).reject(&:even?).each do |i|
+      it "does not scan #{i} as free space" do
         expect(tokens[i][0]).not_to eq :free_space
         expect(tokens[i][1]).not_to eq :whitespace
       end
     end
 
-    [0, 2, 10, 14].each { |i| expect(tokens[i][2]).to eq "\n      " }
-
-    [4, 6, 8, 12].each { |i| expect(tokens[i][2]).to eq '  ' }
+    it 'sets the correct text' do
+      [0, 2, 10, 14].each { |i| expect(tokens[i][2]).to eq "\n      " }
+      [4, 6, 8, 12].each { |i| expect(tokens[i][2]).to eq '  ' }
+    end
   end
 
-  specify('scan free space comments') do
-    regexp = /
+  describe('scan free space comments') do
+    include_examples 'scan', /
       a + # A + comment
       b  ?  # B ? comment
       c  {2,3} # C {2,3} comment
       d + | e + # D|E comment
-    /x
-
-    tokens = RS.scan(regexp)
-
-    [
-      [ 5, :free_space, :comment,  "# A + comment\n",      11,  25],
-      [11, :free_space, :comment,  "# B ? comment\n",      37,  51],
-      [17, :free_space, :comment,  "# C {2,3} comment\n",  66,  84],
-      [29, :free_space, :comment,  "# D|E comment\n",     100, 114],
-    ].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
+    /x,
+      5  => [:free_space, :comment,  "# A + comment\n",      11,  25],
+      11 => [:free_space, :comment,  "# B ? comment\n",      37,  51],
+      17 => [:free_space, :comment,  "# C {2,3} comment\n",  66,  84],
+      29 => [:free_space, :comment,  "# D|E comment\n",     100, 114]
   end
 
-  specify('scan free space inlined') do
-    regexp = /a b(?x:c d e)f g/
-
-    tokens = RS.scan(regexp)
-
-    [
-      [0, :literal,    :literal,     'a b',   0,  3],
-      [1, :group,      :options,     '(?x:',  3,  7],
-      [2, :literal,    :literal,     'c',     7,  8],
-      [3, :free_space, :whitespace,  ' ',     8,  9],
-      [4, :literal,    :literal,     'd',     9, 10],
-      [5, :free_space, :whitespace,  ' ',    10, 11],
-      [6, :literal,    :literal,     'e',    11, 12],
-      [7, :group,      :close,       ')',    12, 13],
-      [8, :literal,    :literal,     'f g',  13, 16]
-    ].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
+  describe('scan free space inlined') do
+    include_examples 'scan', /a b(?x:c d e)f g/,
+      0 => [:literal,    :literal,     'a b',   0,  3],
+      1 => [:group,      :options,     '(?x:',  3,  7],
+      2 => [:literal,    :literal,     'c',     7,  8],
+      3 => [:free_space, :whitespace,  ' ',     8,  9],
+      4 => [:literal,    :literal,     'd',     9, 10],
+      5 => [:free_space, :whitespace,  ' ',    10, 11],
+      6 => [:literal,    :literal,     'e',    11, 12],
+      7 => [:group,      :close,       ')',    12, 13],
+      8 => [:literal,    :literal,     'f g',  13, 16]
   end
 
-  specify('scan free space nested') do
-    regexp = /a b(?x:c d(?-x:e f)g h)i j/
-
-    tokens = RS.scan(regexp)
-
-    [
-      [ 0, :literal,     :literal,     'a b',     0,  3],
-      [ 1, :group,       :options,     '(?x:',    3,  7],
-      [ 2, :literal,     :literal,     'c',       7,  8],
-      [ 3, :free_space,  :whitespace,  ' ',       8,  9],
-      [ 4, :literal,     :literal,     'd',       9, 10],
-      [ 5, :group,       :options,     '(?-x:',  10, 15],
-      [ 6, :literal,     :literal,     'e f',    15, 18],
-      [ 7, :group,       :close,       ')',      18, 19],
-      [ 8, :literal,     :literal,     'g',      19, 20],
-      [ 9, :free_space,  :whitespace,  ' ',      20, 21],
-      [10, :literal,     :literal,     'h',      21, 22],
-      [11, :group,       :close,       ')',      22, 23],
-      [12, :literal,     :literal,     'i j',    23, 26]
-    ].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
+  describe('scan free space nested') do
+    include_examples 'scan', /a b(?x:c d(?-x:e f)g h)i j/,
+      0  => [:literal,     :literal,     'a b',     0,  3],
+      1  => [:group,       :options,     '(?x:',    3,  7],
+      2  => [:literal,     :literal,     'c',       7,  8],
+      3  => [:free_space,  :whitespace,  ' ',       8,  9],
+      4  => [:literal,     :literal,     'd',       9, 10],
+      5  => [:group,       :options,     '(?-x:',  10, 15],
+      6  => [:literal,     :literal,     'e f',    15, 18],
+      7  => [:group,       :close,       ')',      18, 19],
+      8  => [:literal,     :literal,     'g',      19, 20],
+      9  => [:free_space,  :whitespace,  ' ',      20, 21],
+      10 => [:literal,     :literal,     'h',      21, 22],
+      11 => [:group,       :close,       ')',      22, 23],
+      12 => [:literal,     :literal,     'i j',    23, 26]
   end
 
-  specify('scan free space nested groups') do
-    regexp = /(a (b(?x: (c d) (?-x:(e f) )g) h)i j)/
-
-    tokens = RS.scan(regexp)
-
-    [
-      [ 0, :group,       :capture,     '(',       0,  1],
-      [ 1, :literal,     :literal,     'a ',      1,  3],
-      [ 2, :group,       :capture,     '(',       3,  4],
-      [ 3, :literal,     :literal,     'b',       4,  5],
-      [ 4, :group,       :options,     '(?x:',    5,  9],
-      [ 5, :free_space,  :whitespace,  ' ',       9, 10],
-      [ 6, :group,       :capture,     '(',      10, 11],
-      [ 7, :literal,     :literal,     'c',      11, 12],
-      [ 8, :free_space,  :whitespace,  ' ',      12, 13],
-      [ 9, :literal,     :literal,     'd',      13, 14],
-      [10, :group,       :close,       ')',      14, 15],
-      [11, :free_space,  :whitespace,  ' ',      15, 16],
-      [12, :group,       :options,     '(?-x:',  16, 21],
-      [13, :group,       :capture,     '(',      21, 22],
-      [14, :literal,     :literal,     'e f',    22, 25],
-      [15, :group,       :close,       ')',      25, 26],
-      [16, :literal,     :literal,     ' ',      26, 27],
-      [17, :group,       :close,       ')',      27, 28],
-      [18, :literal,     :literal,     'g',      28, 29],
-      [19, :group,       :close,       ')',      29, 30],
-      [20, :literal,     :literal,     ' h',     30, 32],
-      [21, :group,       :close,       ')',      32, 33],
-      [22, :literal,     :literal,     'i j',    33, 36],
-      [23, :group,       :close,       ')',      36, 37]
-    ].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
+  describe('scan free space nested groups') do
+    include_examples 'scan', /(a (b(?x: (c d) (?-x:(e f) )g) h)i j)/,
+      0  => [:group,       :capture,     '(',       0,  1],
+      1  => [:literal,     :literal,     'a ',      1,  3],
+      2  => [:group,       :capture,     '(',       3,  4],
+      3  => [:literal,     :literal,     'b',       4,  5],
+      4  => [:group,       :options,     '(?x:',    5,  9],
+      5  => [:free_space,  :whitespace,  ' ',       9, 10],
+      6  => [:group,       :capture,     '(',      10, 11],
+      7  => [:literal,     :literal,     'c',      11, 12],
+      8  => [:free_space,  :whitespace,  ' ',      12, 13],
+      9  => [:literal,     :literal,     'd',      13, 14],
+      10 => [:group,       :close,       ')',      14, 15],
+      11 => [:free_space,  :whitespace,  ' ',      15, 16],
+      12 => [:group,       :options,     '(?-x:',  16, 21],
+      13 => [:group,       :capture,     '(',      21, 22],
+      14 => [:literal,     :literal,     'e f',    22, 25],
+      15 => [:group,       :close,       ')',      25, 26],
+      16 => [:literal,     :literal,     ' ',      26, 27],
+      17 => [:group,       :close,       ')',      27, 28],
+      18 => [:literal,     :literal,     'g',      28, 29],
+      19 => [:group,       :close,       ')',      29, 30],
+      20 => [:literal,     :literal,     ' h',     30, 32],
+      21 => [:group,       :close,       ')',      32, 33],
+      22 => [:literal,     :literal,     'i j',    33, 36],
+      23 => [:group,       :close,       ')',      36, 37]
   end
 
-  specify('scan free space switch groups') do
-    regexp = /(a (b((?x) (c d) ((?-x)(e f) )g) h)i j)/
-
-    tokens = RS.scan(regexp)
-
-    [
-      [ 0, :group,      :capture,        '(',     0,  1],
-      [ 1, :literal,    :literal,        'a ',    1,  3],
-      [ 2, :group,      :capture,        '(',     3,  4],
-      [ 3, :literal,    :literal,        'b',     4,  5],
-      [ 4, :group,      :capture,        '(',     5,  6],
-      [ 5, :group,      :options_switch, '(?x',   6,  9],
-      [ 6, :group,      :close,           ')',    9,  10],
-      [ 7, :free_space, :whitespace,      ' ',    10, 11],
-      [ 8, :group,      :capture,         '(',    11, 12],
-      [ 9, :literal,    :literal,         'c',    12, 13],
-      [10, :free_space, :whitespace,      ' ',    13, 14],
-      [11, :literal,    :literal,         'd',    14, 15],
-      [12, :group,      :close,           ')',    15, 16],
-      [13, :free_space, :whitespace,      ' ',    16, 17],
-      [14, :group,      :capture,         '(',    17, 18],
-      [15, :group,      :options_switch, '(?-x',  18, 22],
-      [16, :group,      :close,          ')',     22, 23],
-      [17, :group,      :capture,        '(',     23, 24],
-      [18, :literal,    :literal,        'e f',   24, 27],
-      [19, :group,      :close,          ')',     27, 28],
-      [20, :literal,    :literal,        ' ',     28, 29],
-      [21, :group,      :close,          ')',     29, 30],
-      [22, :literal,    :literal,        'g',     30, 31],
-      [23, :group,      :close,          ')',     31, 32],
-      [24, :literal,    :literal,        ' h',    32, 34],
-      [25, :group,      :close,          ')',     34, 35],
-      [26, :literal,    :literal,        'i j',   35, 38],
-      [27, :group,      :close,          ')',     38, 39]
-    ].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
+  describe('scan free space switch groups') do
+    include_examples 'scan', /(a (b((?x) (c d) ((?-x)(e f) )g) h)i j)/,
+      0  => [:group,      :capture,        '(',     0,  1],
+      1  => [:literal,    :literal,        'a ',    1,  3],
+      2  => [:group,      :capture,        '(',     3,  4],
+      3  => [:literal,    :literal,        'b',     4,  5],
+      4  => [:group,      :capture,        '(',     5,  6],
+      5  => [:group,      :options_switch, '(?x',   6,  9],
+      6  => [:group,      :close,           ')',    9,  10],
+      7  => [:free_space, :whitespace,      ' ',    10, 11],
+      8  => [:group,      :capture,         '(',    11, 12],
+      9  => [:literal,    :literal,         'c',    12, 13],
+      10 => [:free_space, :whitespace,      ' ',    13, 14],
+      11 => [:literal,    :literal,         'd',    14, 15],
+      12 => [:group,      :close,           ')',    15, 16],
+      13 => [:free_space, :whitespace,      ' ',    16, 17],
+      14 => [:group,      :capture,         '(',    17, 18],
+      15 => [:group,      :options_switch, '(?-x',  18, 22],
+      16 => [:group,      :close,          ')',     22, 23],
+      17 => [:group,      :capture,        '(',     23, 24],
+      18 => [:literal,    :literal,        'e f',   24, 27],
+      19 => [:group,      :close,          ')',     27, 28],
+      20 => [:literal,    :literal,        ' ',     28, 29],
+      21 => [:group,      :close,          ')',     29, 30],
+      22 => [:literal,    :literal,        'g',     30, 31],
+      23 => [:group,      :close,          ')',     31, 32],
+      24 => [:literal,    :literal,        ' h',    32, 34],
+      25 => [:group,      :close,          ')',     34, 35],
+      26 => [:literal,    :literal,        'i j',   35, 38],
+      27 => [:group,      :close,          ')',     38, 39]
   end
 end