regexp_parser 1.5.0 → 1.8.0

data/spec/lexer/delimiters_spec.rb

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

data/spec/lexer/escapes_spec.rb

@@ -1,38 +1,14 @@
 require 'spec_helper'
 
 RSpec.describe('Escape lexing') do
-  tests = {
-    '\u{62}' => {
-      0     => [:escape,     :codepoint_list,   '\u{62}',        0, 6,   0, 0, 0],
-    },
+  include_examples 'lex', '\u{62}',
+    0 => [:escape,  :codepoint_list, '\u{62}',       0, 6,  0, 0, 0]
 
-    '\u{62 63 64}' => {
-      0     => [:escape,     :codepoint_list,   '\u{62 63 64}',  0, 12,  0, 0, 0],
-    },
+  include_examples 'lex', '\u{62 63 64}',
+    0 => [:escape,  :codepoint_list, '\u{62 63 64}', 0, 12, 0, 0, 0]
 
-    '\u{62 63 64}+' => {
-      0     => [:escape,     :codepoint_list,   '\u{62 63}',     0,  9,  0, 0, 0],
-      1     => [:escape,     :codepoint_list,   '\u{64}',        9,  15, 0, 0, 0],
-      2     => [:quantifier, :one_or_more,      '+',             15, 16, 0, 0, 0],
-    },
-  }
-
-  tests.each_with_index do |(pattern, checks), count|
-    specify("lex_escape_runs_#{count}") do
-      tokens = RL.lex(pattern)
-
-      checks.each do |index, (type, token, text, ts, te, level, set_level, conditional_level)|
-        struct = tokens.at(index)
-
-        expect(struct.type).to eq type
-        expect(struct.token).to eq token
-        expect(struct.text).to eq text
-        expect(struct.ts).to eq ts
-        expect(struct.te).to eq te
-        expect(struct.level).to eq level
-        expect(struct.set_level).to eq set_level
-        expect(struct.conditional_level).to eq conditional_level
-      end
-    end
-  end
+  include_examples 'lex', '\u{62 63 64}+',
+    0 => [:escape,     :codepoint_list, '\u{62 63}',  0,  9,  0, 0, 0],
+    1 => [:escape,     :codepoint_list, '\u{64}',     9,  15, 0, 0, 0],
+    2 => [:quantifier, :one_or_more,    '+',          15, 16, 0, 0, 0]
 end

data/spec/lexer/keep_spec.rb

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

data/spec/lexer/literals_spec.rb

@@ -1,126 +1,89 @@
 require 'spec_helper'
 
 RSpec.describe('Literal lexing') do
-  tests = {
-    # ascii, single byte characters
-    'a' => {
-      0     => [:literal,     :literal,       'a',        0, 1, 0, 0, 0],
-    },
-
-    'ab+' => {
-      0     => [:literal,     :literal,       'a',        0, 1, 0, 0, 0],
-      1     => [:literal,     :literal,       'b',        1, 2, 0, 0, 0],
-      2     => [:quantifier,  :one_or_more,   '+',        2, 3, 0, 0, 0],
-    },
-
-
-    # 2 byte wide characters, Arabic
-    'ا' => {
-      0     => [:literal,     :literal,       'ا',        0, 2, 0, 0, 0],
-    },
-
-    'aاbبcت' => {
-      0     => [:literal,     :literal,       'aاbبcت',   0, 9, 0, 0, 0],
-    },
-
-    'aاbبت?' => {
-      0     => [:literal,     :literal,       'aاbب',     0, 6, 0, 0, 0],
-      1     => [:literal,     :literal,       'ت',        6, 8, 0, 0, 0],
-      2     => [:quantifier,  :zero_or_one,   '?',        8, 9, 0, 0, 0],
-    },
-
-    'aا?bبcت+' => {
-      0     => [:literal,     :literal,       'a',        0, 1, 0, 0, 0],
-      1     => [:literal,     :literal,       'ا',        1, 3, 0, 0, 0],
-      2     => [:quantifier,  :zero_or_one,   '?',        3, 4, 0, 0, 0],
-      3     => [:literal,     :literal,       'bبc',      4, 8, 0, 0, 0],
-      4     => [:literal,     :literal,       'ت',        8, 10, 0, 0, 0],
-      5     => [:quantifier,  :one_or_more,   '+',        10, 11, 0, 0, 0],
-    },
-
-    'a(اbب+)cت?' => {
-      0     => [:literal,     :literal,       'a',        0, 1, 0, 0, 0],
-      1     => [:group,       :capture,       '(',        1, 2, 0, 0, 0],
-      2     => [:literal,     :literal,       'اb',       2, 5, 1, 0, 0],
-      3     => [:literal,     :literal,       'ب',        5, 7, 1, 0, 0],
-      4     => [:quantifier,  :one_or_more,   '+',        7, 8, 1, 0, 0],
-      5     => [:group,       :close,         ')',        8, 9, 0, 0, 0],
-      6     => [:literal,     :literal,       'c',        9, 10, 0, 0, 0],
-      7     => [:literal,     :literal,       'ت',        10, 12, 0, 0, 0],
-      8     => [:quantifier,  :zero_or_one,   '?',        12, 13, 0, 0, 0],
-    },
-
-
-    # 3 byte wide characters, Japanese
-    'ab?れます+cd' => {
-      0     => [:literal,     :literal,       'a',        0, 1, 0, 0, 0],
-      1     => [:literal,     :literal,       'b',        1, 2, 0, 0, 0],
-      2     => [:quantifier,  :zero_or_one,   '?',        2, 3, 0, 0, 0],
-      3     => [:literal,     :literal,       'れま',     3, 9, 0, 0, 0],
-      4     => [:literal,     :literal,       'す',       9, 12, 0, 0, 0],
-      5     => [:quantifier,  :one_or_more,   '+',        12, 13, 0, 0, 0],
-      6     => [:literal,     :literal,       'cd',       13, 15, 0, 0, 0],
-    },
-
-
-    # 4 byte wide characters, Osmanya
-    '𐒀𐒁?𐒂ab+𐒃' => {
-      0     => [:literal,     :literal,       '𐒀',        0, 4, 0, 0, 0],
-      1     => [:literal,     :literal,       '𐒁',        4, 8, 0, 0, 0],
-      2     => [:quantifier,  :zero_or_one,   '?',        8, 9, 0, 0, 0],
-      3     => [:literal,     :literal,       '𐒂a',       9, 14, 0, 0, 0],
-      4     => [:literal,     :literal,       'b',        14, 15, 0, 0, 0],
-      5     => [:quantifier,  :one_or_more,   '+',        15, 16, 0, 0, 0],
-      6     => [:literal,     :literal,       '𐒃',        16, 20, 0, 0, 0],
-    },
-
-    'mu𝄞?si*𝄫c+' => {
-      0     => [:literal,     :literal,       'mu',       0, 2, 0, 0, 0],
-      1     => [:literal,     :literal,       '𝄞',        2, 6, 0, 0, 0],
-      2     => [:quantifier,  :zero_or_one,   '?',        6, 7, 0, 0, 0],
-      3     => [:literal,     :literal,       's',        7, 8, 0, 0, 0],
-      4     => [:literal,     :literal,       'i',        8, 9, 0, 0, 0],
-      5     => [:quantifier,  :zero_or_more,  '*',        9, 10, 0, 0, 0],
-      6     => [:literal,     :literal,       '𝄫',        10, 14, 0, 0, 0],
-      7     => [:literal,     :literal,       'c',        14, 15, 0, 0, 0],
-      8     => [:quantifier,  :one_or_more,   '+',        15, 16, 0, 0, 0],
-    },
-  }
-
-  tests.each_with_index do |(pattern, checks), count|
-    specify("lex_literal_runs_#{count}") do
-      tokens = RL.lex(pattern)
-
-      checks.each do |index, (type, token, text, ts, te, level, set_level, conditional_level)|
-        struct = tokens.at(index)
-
-        expect(struct.type).to eq type
-        expect(struct.token).to eq token
-        expect(struct.text).to eq text
-        expect(struct.ts).to eq ts
-        expect(struct.te).to eq te
-        expect(struct.level).to eq level
-        expect(struct.set_level).to eq set_level
-        expect(struct.conditional_level).to eq conditional_level
-      end
-    end
-  end
+  # ascii, single byte characters
+  include_examples 'lex', 'a',
+    0 => [:literal,     :literal,       'a',        0, 1, 0, 0, 0]
+
+  include_examples 'lex', 'ab+',
+    0 => [:literal,     :literal,       'a',        0, 1, 0, 0, 0],
+    1 => [:literal,     :literal,       'b',        1, 2, 0, 0, 0],
+    2 => [:quantifier,  :one_or_more,   '+',        2, 3, 0, 0, 0]
+
+  # 2 byte wide characters, Arabic
+  include_examples 'lex', 'ا',
+    0 => [:literal,     :literal,       'ا',        0, 2, 0, 0, 0]
+
+  include_examples 'lex', 'aاbبcت',
+    0 => [:literal,     :literal,       'aاbبcت',   0, 9, 0, 0, 0]
+
+  include_examples 'lex', 'aاbبت?',
+    0 => [:literal,     :literal,       'aاbب',     0, 6, 0, 0, 0],
+    1 => [:literal,     :literal,       'ت',        6, 8, 0, 0, 0],
+    2 => [:quantifier,  :zero_or_one,   '?',        8, 9, 0, 0, 0]
+
+  include_examples 'lex', 'aا?bبcت+',
+    0 => [:literal,     :literal,       'a',        0, 1, 0, 0, 0],
+    1 => [:literal,     :literal,       'ا',        1, 3, 0, 0, 0],
+    2 => [:quantifier,  :zero_or_one,   '?',        3, 4, 0, 0, 0],
+    3 => [:literal,     :literal,       'bبc',      4, 8, 0, 0, 0],
+    4 => [:literal,     :literal,       'ت',        8, 10, 0, 0, 0],
+    5 => [:quantifier,  :one_or_more,   '+',        10, 11, 0, 0, 0]
+
+  include_examples 'lex', 'a(اbب+)cت?',
+    0 => [:literal,     :literal,       'a',        0, 1, 0, 0, 0],
+    1 => [:group,       :capture,       '(',        1, 2, 0, 0, 0],
+    2 => [:literal,     :literal,       'اb',       2, 5, 1, 0, 0],
+    3 => [:literal,     :literal,       'ب',        5, 7, 1, 0, 0],
+    4 => [:quantifier,  :one_or_more,   '+',        7, 8, 1, 0, 0],
+    5 => [:group,       :close,         ')',        8, 9, 0, 0, 0],
+    6 => [:literal,     :literal,       'c',        9, 10, 0, 0, 0],
+    7 => [:literal,     :literal,       'ت',        10, 12, 0, 0, 0],
+    8 => [:quantifier,  :zero_or_one,   '?',        12, 13, 0, 0, 0]
+
+  # 3 byte wide characters, Japanese
+  include_examples 'lex', 'ab?れます+cd',
+    0 => [:literal,     :literal,       'a',        0, 1, 0, 0, 0],
+    1 => [:literal,     :literal,       'b',        1, 2, 0, 0, 0],
+    2 => [:quantifier,  :zero_or_one,   '?',        2, 3, 0, 0, 0],
+    3 => [:literal,     :literal,       'れま',     3, 9, 0, 0, 0],
+    4 => [:literal,     :literal,       'す',       9, 12, 0, 0, 0],
+    5 => [:quantifier,  :one_or_more,   '+',        12, 13, 0, 0, 0],
+    6 => [:literal,     :literal,       'cd',       13, 15, 0, 0, 0]
+
+  # 4 byte wide characters, Osmanya
+  include_examples 'lex', '𐒀𐒁?𐒂ab+𐒃',
+    0 => [:literal,     :literal,       '𐒀',        0, 4, 0, 0, 0],
+    1 => [:literal,     :literal,       '𐒁',        4, 8, 0, 0, 0],
+    2 => [:quantifier,  :zero_or_one,   '?',        8, 9, 0, 0, 0],
+    3 => [:literal,     :literal,       '𐒂a',       9, 14, 0, 0, 0],
+    4 => [:literal,     :literal,       'b',        14, 15, 0, 0, 0],
+    5 => [:quantifier,  :one_or_more,   '+',        15, 16, 0, 0, 0],
+    6 => [:literal,     :literal,       '𐒃',        16, 20, 0, 0, 0]
+
+  include_examples 'lex', 'mu𝄞?si*𝄫c+',
+    0 => [:literal,     :literal,       'mu',       0, 2, 0, 0, 0],
+    1 => [:literal,     :literal,       '𝄞',        2, 6, 0, 0, 0],
+    2 => [:quantifier,  :zero_or_one,   '?',        6, 7, 0, 0, 0],
+    3 => [:literal,     :literal,       's',        7, 8, 0, 0, 0],
+    4 => [:literal,     :literal,       'i',        8, 9, 0, 0, 0],
+    5 => [:quantifier,  :zero_or_more,  '*',        9, 10, 0, 0, 0],
+    6 => [:literal,     :literal,       '𝄫',        10, 14, 0, 0, 0],
+    7 => [:literal,     :literal,       'c',        14, 15, 0, 0, 0],
+    8 => [:quantifier,  :one_or_more,   '+',        15, 16, 0, 0, 0]
 
   specify('lex single 2 byte char') do
     tokens = RL.lex("\u0627+")
-
-    expect(tokens.length).to eq 2
+    expect(tokens.count).to eq 2
   end
 
   specify('lex single 3 byte char') do
     tokens = RL.lex("\u308C+")
-
-    expect(tokens.length).to eq 2
+    expect(tokens.count).to eq 2
   end
 
   specify('lex single 4 byte char') do
     tokens = RL.lex("\u{1D11E}+")
-
-    expect(tokens.length).to eq 2
+    expect(tokens.count).to eq 2
   end
 end

data/spec/lexer/nesting_spec.rb

@@ -1,130 +1,99 @@
 require 'spec_helper'
 
 RSpec.describe('Nesting lexing') do
-  tests = {
-    '(((b)))' => {
-      0     => [:group,       :capture,       '(',      0,  1, 0, 0, 0],
-      1     => [:group,       :capture,       '(',      1,  2, 1, 0, 0],
-      2     => [:group,       :capture,       '(',      2,  3, 2, 0, 0],
-      3     => [:literal,     :literal,       'b',      3,  4, 3, 0, 0],
-      4     => [:group,       :close,         ')',      4,  5, 2, 0, 0],
-      5     => [:group,       :close,         ')',      5,  6, 1, 0, 0],
-      6     => [:group,       :close,         ')',      6,  7, 0, 0, 0],
-    },
+  include_examples 'lex', /(((b)))/,
+    0 => [:group,    :capture,   '(',  0,  1, 0, 0, 0],
+    1 => [:group,    :capture,   '(',  1,  2, 1, 0, 0],
+    2 => [:group,    :capture,   '(',  2,  3, 2, 0, 0],
+    3 => [:literal,  :literal,   'b',  3,  4, 3, 0, 0],
+    4 => [:group,    :close,     ')',  4,  5, 2, 0, 0],
+    5 => [:group,    :close,     ')',  5,  6, 1, 0, 0],
+    6 => [:group,    :close,     ')',  6,  7, 0, 0, 0]
 
-    '(\((b)\))' => {
-      0     => [:group,       :capture,       '(',      0,  1, 0, 0, 0],
-      1     => [:escape,      :group_open,    '\(',     1,  3, 1, 0, 0],
-      2     => [:group,       :capture,       '(',      3,  4, 1, 0, 0],
-      3     => [:literal,     :literal,       'b',      4,  5, 2, 0, 0],
-      4     => [:group,       :close,         ')',      5,  6, 1, 0, 0],
-      5     => [:escape,      :group_close,   '\)',     6,  8, 1, 0, 0],
-      6     => [:group,       :close,         ')',      8,  9, 0, 0, 0],
-    },
+  include_examples 'lex', /(\((b)\))/,
+    0 => [:group,    :capture,      '(',   0,  1, 0, 0, 0],
+    1 => [:escape,   :group_open,   '\(',  1,  3, 1, 0, 0],
+    2 => [:group,    :capture,      '(',   3,  4, 1, 0, 0],
+    3 => [:literal,  :literal,      'b',   4,  5, 2, 0, 0],
+    4 => [:group,    :close,        ')',   5,  6, 1, 0, 0],
+    5 => [:escape,   :group_close,  '\)',  6,  8, 1, 0, 0],
+    6 => [:group,    :close,        ')',   8,  9, 0, 0, 0]
 
-    '(?>a(?>b(?>c)))' => {
-      0     => [:group,       :atomic,        '(?>',    0,  3, 0, 0, 0],
-      2     => [:group,       :atomic,        '(?>',    4,  7, 1, 0, 0],
-      4     => [:group,       :atomic,        '(?>',    8, 11, 2, 0, 0],
-      6     => [:group,       :close,         ')',     12, 13, 2, 0, 0],
-      7     => [:group,       :close,         ')',     13, 14, 1, 0, 0],
-      8     => [:group,       :close,         ')',     14, 15, 0, 0, 0],
-    },
+  include_examples 'lex', /(?>a(?>b(?>c)))/,
+    0 => [:group,    :atomic,       '(?>',  0,  3, 0, 0, 0],
+    2 => [:group,    :atomic,       '(?>',  4,  7, 1, 0, 0],
+    4 => [:group,    :atomic,       '(?>',  8, 11, 2, 0, 0],
+    6 => [:group,    :close,        ')',   12, 13, 2, 0, 0],
+    7 => [:group,    :close,        ')',   13, 14, 1, 0, 0],
+    8 => [:group,    :close,        ')',   14, 15, 0, 0, 0]
 
-    '(?:a(?:b(?:c)))' => {
-      0     => [:group,       :passive,       '(?:',    0,  3, 0, 0, 0],
-      2     => [:group,       :passive,       '(?:',    4,  7, 1, 0, 0],
-      4     => [:group,       :passive,       '(?:',    8, 11, 2, 0, 0],
-      6     => [:group,       :close,         ')',     12, 13, 2, 0, 0],
-      7     => [:group,       :close,         ')',     13, 14, 1, 0, 0],
-      8     => [:group,       :close,         ')',     14, 15, 0, 0, 0],
-    },
+  include_examples 'lex', /(?:a(?:b(?:c)))/,
+    0 => [:group,       :passive,       '(?:',    0,  3, 0, 0, 0],
+    2 => [:group,       :passive,       '(?:',    4,  7, 1, 0, 0],
+    4 => [:group,       :passive,       '(?:',    8, 11, 2, 0, 0],
+    6 => [:group,       :close,         ')',     12, 13, 2, 0, 0],
+    7 => [:group,       :close,         ')',     13, 14, 1, 0, 0],
+    8 => [:group,       :close,         ')',     14, 15, 0, 0, 0]
 
-    '(?=a(?!b(?<=c(?<!d))))' => {
-      0     => [:assertion,   :lookahead,     '(?=',    0,  3, 0, 0, 0],
-      2     => [:assertion,   :nlookahead,    '(?!',    4,  7, 1, 0, 0],
-      4     => [:assertion,   :lookbehind,    '(?<=',   8, 12, 2, 0, 0],
-      6     => [:assertion,   :nlookbehind,   '(?<!',  13, 17, 3, 0, 0],
-      8     => [:group,       :close,         ')',     18, 19, 3, 0, 0],
-      9     => [:group,       :close,         ')',     19, 20, 2, 0, 0],
-      10    => [:group,       :close,         ')',     20, 21, 1, 0, 0],
-      11    => [:group,       :close,         ')',     21, 22, 0, 0, 0],
-    },
+  include_examples 'lex', /(?=a(?!b(?<=c(?<!d))))/,
+    0  => [:assertion,   :lookahead,     '(?=',    0,  3, 0, 0, 0],
+    2  => [:assertion,   :nlookahead,    '(?!',    4,  7, 1, 0, 0],
+    4  => [:assertion,   :lookbehind,    '(?<=',   8, 12, 2, 0, 0],
+    6  => [:assertion,   :nlookbehind,   '(?<!',  13, 17, 3, 0, 0],
+    8  => [:group,       :close,         ')',     18, 19, 3, 0, 0],
+    9  => [:group,       :close,         ')',     19, 20, 2, 0, 0],
+    10 => [:group,       :close,         ')',     20, 21, 1, 0, 0],
+    11 => [:group,       :close,         ')',     21, 22, 0, 0, 0]
 
-    '((?#a)b(?#c)d(?#e))' => {
-      0     => [:group,       :capture,       '(',      0,  1, 0, 0, 0],
-      1     => [:group,       :comment,       '(?#a)',  1,  6, 1, 0, 0],
-      3     => [:group,       :comment,       '(?#c)',  7, 12, 1, 0, 0],
-      5     => [:group,       :comment,       '(?#e)', 13, 18, 1, 0, 0],
-      6     => [:group,       :close,         ')',     18, 19, 0, 0, 0],
-    },
+  include_examples 'lex', /((?#a)b(?#c)d(?#e))/,
+    0 => [:group,       :capture,       '(',      0,  1, 0, 0, 0],
+    1 => [:group,       :comment,       '(?#a)',  1,  6, 1, 0, 0],
+    3 => [:group,       :comment,       '(?#c)',  7, 12, 1, 0, 0],
+    5 => [:group,       :comment,       '(?#e)', 13, 18, 1, 0, 0],
+    6 => [:group,       :close,         ')',     18, 19, 0, 0, 0]
 
-    'a[b-e]f' => {
-      1     => [:set,         :open,          '[',      1,  2, 0, 0, 0],
-      2     => [:literal,     :literal,       'b',      2,  3, 0, 1, 0],
-      3     => [:set,         :range,         '-',      3,  4, 0, 1, 0],
-      4     => [:literal,     :literal,       'e',      4,  5, 0, 1, 0],
-      5     => [:set,         :close,         ']',      5,  6, 0, 0, 0],
-    },
+  include_examples 'lex', /a[b-e]f/,
+    1 => [:set,         :open,          '[',      1,  2, 0, 0, 0],
+    2 => [:literal,     :literal,       'b',      2,  3, 0, 1, 0],
+    3 => [:set,         :range,         '-',      3,  4, 0, 1, 0],
+    4 => [:literal,     :literal,       'e',      4,  5, 0, 1, 0],
+    5 => [:set,         :close,         ']',      5,  6, 0, 0, 0]
 
-    '[[:word:]&&[^c]z]' => {
-      0     => [:set,         :open,          '[',      0,  1, 0, 0, 0],
-      1     => [:posixclass,  :word, '[:word:]',        1,  9, 0, 1, 0],
-      2     => [:set,         :intersection,  '&&',     9, 11, 0, 1, 0],
-      3     => [:set,         :open,          '[',     11, 12, 0, 1, 0],
-      4     => [:set,         :negate,        '^',     12, 13, 0, 2, 0],
-      5     => [:literal,     :literal,       'c',     13, 14, 0, 2, 0],
-      6     => [:set,         :close,         ']',     14, 15, 0, 1, 0],
-      7     => [:literal,     :literal,       'z',     15, 16, 0, 1, 0],
-      8     => [:set,         :close,         ']',     16, 17, 0, 0, 0],
-    },
+  include_examples 'lex', /[[:word:]&&[^c]z]/,
+    0 => [:set,         :open,          '[',          0,  1, 0, 0, 0],
+    1 => [:posixclass,  :word,          '[:word:]',   1,  9, 0, 1, 0],
+    2 => [:set,         :intersection,  '&&',         9, 11, 0, 1, 0],
+    3 => [:set,         :open,          '[',         11, 12, 0, 1, 0],
+    4 => [:set,         :negate,        '^',         12, 13, 0, 2, 0],
+    5 => [:literal,     :literal,       'c',         13, 14, 0, 2, 0],
+    6 => [:set,         :close,         ']',         14, 15, 0, 1, 0],
+    7 => [:literal,     :literal,       'z',         15, 16, 0, 1, 0],
+    8 => [:set,         :close,         ']',         16, 17, 0, 0, 0]
 
-    '[\p{word}&&[^c]z]' => {
-      0     => [:set,         :open,          '[',      0,  1, 0, 0, 0],
-      1     => [:property,    :word, '\p{word}',        1,  9, 0, 1, 0],
-      2     => [:set,         :intersection,  '&&',     9, 11, 0, 1, 0],
-      3     => [:set,         :open,          '[',     11, 12, 0, 1, 0],
-      4     => [:set,         :negate,        '^',     12, 13, 0, 2, 0],
-      5     => [:literal,     :literal,       'c',     13, 14, 0, 2, 0],
-      6     => [:set,         :close,         ']',     14, 15, 0, 1, 0],
-      7     => [:literal,     :literal,       'z',     15, 16, 0, 1, 0],
-      8     => [:set,         :close,         ']',     16, 17, 0, 0, 0],
-    },
+  include_examples 'lex', /[\p{word}&&[^c]z]/,
+    0 => [:set,         :open,          '[',          0,  1, 0, 0, 0],
+    1 => [:property,    :word,          '\p{word}',   1,  9, 0, 1, 0],
+    2 => [:set,         :intersection,  '&&',         9, 11, 0, 1, 0],
+    3 => [:set,         :open,          '[',         11, 12, 0, 1, 0],
+    4 => [:set,         :negate,        '^',         12, 13, 0, 2, 0],
+    5 => [:literal,     :literal,       'c',         13, 14, 0, 2, 0],
+    6 => [:set,         :close,         ']',         14, 15, 0, 1, 0],
+    7 => [:literal,     :literal,       'z',         15, 16, 0, 1, 0],
+    8 => [:set,         :close,         ']',         16, 17, 0, 0, 0]
 
-    '[a[b[c[d-g]]]]' => {
-      0     => [:set,         :open,          '[',      0,  1, 0, 0, 0],
-      1     => [:literal,     :literal,       'a',      1,  2, 0, 1, 0],
-      2     => [:set,         :open,          '[',      2,  3, 0, 1, 0],
-      3     => [:literal,     :literal,       'b',      3,  4, 0, 2, 0],
-      4     => [:set,         :open,          '[',      4,  5, 0, 2, 0],
-      5     => [:literal,     :literal,       'c',      5,  6, 0, 3, 0],
-      6     => [:set,         :open,          '[',      6,  7, 0, 3, 0],
-      7     => [:literal,     :literal,       'd',      7,  8, 0, 4, 0],
-      8     => [:set,         :range,         '-',      8,  9, 0, 4, 0],
-      9     => [:literal,     :literal,       'g',      9, 10, 0, 4, 0],
-      10    => [:set,         :close,         ']',     10, 11, 0, 3, 0],
-      11    => [:set,         :close,         ']',     11, 12, 0, 2, 0],
-      12    => [:set,         :close,         ']',     12, 13, 0, 1, 0],
-      13    => [:set,         :close,         ']',     13, 14, 0, 0, 0],
-    },
-  }
-
-  tests.each_with_index do |(pattern, checks), count|
-    specify("lex_nesting_in_'#{pattern}'_#{count}") do
-      tokens = RL.lex(pattern, 'ruby/1.9')
-
-      checks.each do |offset, (type, token, text, ts, te, level, set_level, conditional_level)|
-        struct = tokens.at(offset)
-
-        expect(struct.type).to eq type
-        expect(struct.token).to eq token
-        expect(struct.text).to eq text
-        expect(struct.ts).to eq ts
-        expect(struct.te).to eq te
-        expect(struct.level).to eq level
-        expect(struct.set_level).to eq set_level
-        expect(struct.conditional_level).to eq conditional_level
-      end
-    end
-  end
+  include_examples 'lex', /[a[b[c[d-g]]]]/,
+    0  => [:set,         :open,          '[',      0,  1, 0, 0, 0],
+    1  => [:literal,     :literal,       'a',      1,  2, 0, 1, 0],
+    2  => [:set,         :open,          '[',      2,  3, 0, 1, 0],
+    3  => [:literal,     :literal,       'b',      3,  4, 0, 2, 0],
+    4  => [:set,         :open,          '[',      4,  5, 0, 2, 0],
+    5  => [:literal,     :literal,       'c',      5,  6, 0, 3, 0],
+    6  => [:set,         :open,          '[',      6,  7, 0, 3, 0],
+    7  => [:literal,     :literal,       'd',      7,  8, 0, 4, 0],
+    8  => [:set,         :range,         '-',      8,  9, 0, 4, 0],
+    9  => [:literal,     :literal,       'g',      9, 10, 0, 4, 0],
+    10 => [:set,         :close,         ']',     10, 11, 0, 3, 0],
+    11 => [:set,         :close,         ']',     11, 12, 0, 2, 0],
+    12 => [:set,         :close,         ']',     12, 13, 0, 1, 0],
+    13 => [:set,         :close,         ']',     13, 14, 0, 0, 0]
 end