regexp_parser 1.5.0 → 1.5.1

data/spec/scanner/quantifiers_spec.rb

@@ -1,35 +1,20 @@
 require 'spec_helper'
 
 RSpec.describe('Quantifier scanning') do
-  tests = {
-   'a?'     => [:quantifier,  :zero_or_one,             '?'],
-   'a??'    => [:quantifier,  :zero_or_one_reluctant,   '??'],
-   'a?+'    => [:quantifier,  :zero_or_one_possessive,  '?+'],
+  include_examples 'scan', 'a?',     1 => [:quantifier,  :zero_or_one,             '?',     1, 2]
+  include_examples 'scan', 'a??',    1 => [:quantifier,  :zero_or_one_reluctant,   '??',    1, 3]
+  include_examples 'scan', 'a?+',    1 => [:quantifier,  :zero_or_one_possessive,  '?+',    1, 3]
 
-   'a*'     => [:quantifier,  :zero_or_more,            '*'],
-   'a*?'    => [:quantifier,  :zero_or_more_reluctant,  '*?'],
-   'a*+'    => [:quantifier,  :zero_or_more_possessive, '*+'],
+  include_examples 'scan', 'a*',     1 => [:quantifier,  :zero_or_more,            '*',     1, 2]
+  include_examples 'scan', 'a*?',    1 => [:quantifier,  :zero_or_more_reluctant,  '*?',    1, 3]
+  include_examples 'scan', 'a*+',    1 => [:quantifier,  :zero_or_more_possessive, '*+',    1, 3]
 
-   'a+'     => [:quantifier,  :one_or_more,             '+'],
-   'a+?'    => [:quantifier,  :one_or_more_reluctant,   '+?'],
-   'a++'    => [:quantifier,  :one_or_more_possessive,  '++'],
+  include_examples 'scan', 'a+',     1 => [:quantifier,  :one_or_more,             '+',     1, 2]
+  include_examples 'scan', 'a+?',    1 => [:quantifier,  :one_or_more_reluctant,   '+?',    1, 3]
+  include_examples 'scan', 'a++',    1 => [:quantifier,  :one_or_more_possessive,  '++',    1, 3]
 
-   'a{2}'   => [:quantifier,  :interval,                '{2}'],
-   'a{2,}'  => [:quantifier,  :interval,                '{2,}'],
-   'a{,2}'  => [:quantifier,  :interval,                '{,2}'],
-   'a{2,4}' => [:quantifier,  :interval,                '{2,4}'],
-  }
-
-  tests.each_with_index do |(pattern, (type, token, text)), count|
-    name = token == :interval ? "interval_#{count}" : token
-
-    specify("scan_#{type}_#{name}") do
-      tokens = RS.scan(pattern)
-      result = tokens.last
-
-      expect(result[0]).to eq type
-      expect(result[1]).to eq token
-      expect(result[2]).to eq text
-    end
-  end
+  include_examples 'scan', 'a{2}',   1 => [:quantifier,  :interval,                '{2}',   1, 4]
+  include_examples 'scan', 'a{2,}',  1 => [:quantifier,  :interval,                '{2,}',  1, 5]
+  include_examples 'scan', 'a{,2}',  1 => [:quantifier,  :interval,                '{,2}',  1, 5]
+  include_examples 'scan', 'a{2,4}', 1 => [:quantifier,  :interval,                '{2,4}', 1, 6]
 end

data/spec/scanner/refcalls_spec.rb

@@ -1,52 +1,36 @@
 require 'spec_helper'
 
 RSpec.describe('RefCall scanning') do
-  tests = {
-    # Traditional numerical group back-reference
-    '(abc)\1'           => [3, :backref, :number,                  '\1',         5, 7],
-
-    # Group back-references, named, numbered, and relative
-    '(?<X>abc)\k<X>'    => [3, :backref, :name_ref_ab,             '\k<X>',      9, 14],
-    "(?<X>abc)\\k'X'"   => [3, :backref, :name_ref_sq,             "\\k'X'",     9, 14],
-
-    '(abc)\k<1>'        => [3, :backref, :number_ref_ab,           '\k<1>',      5, 10],
-    "(abc)\\k'1'"       => [3, :backref, :number_ref_sq,           "\\k'1'",     5, 10],
-
-    '(abc)\k<-1>'       => [3, :backref, :number_rel_ref_ab,       '\k<-1>',     5, 11],
-    "(abc)\\k'-1'"      => [3, :backref, :number_rel_ref_sq,       "\\k'-1'",    5, 11],
-
-    # Sub-expression invocation, named, numbered, and relative
-    '(?<X>abc)\g<X>'    => [3, :backref, :name_call_ab,            '\g<X>',      9, 14],
-    "(?<X>abc)\\g'X'"   => [3, :backref, :name_call_sq,            "\\g'X'",     9, 14],
-
-    '(abc)\g<1>'        => [3, :backref, :number_call_ab,          '\g<1>',      5, 10],
-    "(abc)\\g'1'"       => [3, :backref, :number_call_sq,          "\\g'1'",     5, 10],
-
-    '(abc)\g<-1>'       => [3, :backref, :number_rel_call_ab,      '\g<-1>',     5, 11],
-    "(abc)\\g'-1'"      => [3, :backref, :number_rel_call_sq,      "\\g'-1'",    5, 11],
-
-    '\g<+1>(abc)'       => [0, :backref, :number_rel_call_ab,      '\g<+1>',     0, 6],
-    "\\g'+1'(abc)"      => [0, :backref, :number_rel_call_sq,      "\\g'+1'",    0, 6],
-
-    # Group back-references, with recursion level
-    '(?<X>abc)\k<X-0>'  => [3, :backref, :name_recursion_ref_ab,   '\k<X-0>',    9, 16],
-    "(?<X>abc)\\k'X-0'" => [3, :backref, :name_recursion_ref_sq,   "\\k'X-0'",   9, 16],
-
-    '(abc)\k<1-0>'      => [3, :backref, :number_recursion_ref_ab, '\k<1-0>',    5, 12],
-    "(abc)\\k'1-0'"     => [3, :backref, :number_recursion_ref_sq, "\\k'1-0'",   5, 12],
-  }
-
-  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
-      expect(pattern[ts, te]).to eq text
-    end
-  end
+  # Traditional numerical group back-reference
+  include_examples 'scan', '(abc)\1' ,          3 => [:backref, :number,                  '\1',         5, 7]
+
+  # Group back-references, named, numbered, and relative
+  include_examples 'scan', '(?<X>abc)\k<X>',    3 => [:backref, :name_ref_ab,             '\k<X>',      9, 14]
+  include_examples 'scan', "(?<X>abc)\\k'X'",   3 => [:backref, :name_ref_sq,             "\\k'X'",     9, 14]
+
+  include_examples 'scan', '(abc)\k<1>',        3 => [:backref, :number_ref_ab,           '\k<1>',      5, 10]
+  include_examples 'scan', "(abc)\\k'1'",       3 => [:backref, :number_ref_sq,           "\\k'1'",     5, 10]
+
+  include_examples 'scan', '(abc)\k<-1>',       3 => [:backref, :number_rel_ref_ab,       '\k<-1>',     5, 11]
+  include_examples 'scan', "(abc)\\k'-1'",      3 => [:backref, :number_rel_ref_sq,       "\\k'-1'",    5, 11]
+
+  # Sub-expression invocation, named, numbered, and relative
+  include_examples 'scan', '(?<X>abc)\g<X>',    3 => [:backref, :name_call_ab,            '\g<X>',      9, 14]
+  include_examples 'scan', "(?<X>abc)\\g'X'",   3 => [:backref, :name_call_sq,            "\\g'X'",     9, 14]
+
+  include_examples 'scan', '(abc)\g<1>',        3 => [:backref, :number_call_ab,          '\g<1>',      5, 10]
+  include_examples 'scan', "(abc)\\g'1'",       3 => [:backref, :number_call_sq,          "\\g'1'",     5, 10]
+
+  include_examples 'scan', '(abc)\g<-1>',       3 => [:backref, :number_rel_call_ab,      '\g<-1>',     5, 11]
+  include_examples 'scan', "(abc)\\g'-1'",      3 => [:backref, :number_rel_call_sq,      "\\g'-1'",    5, 11]
+
+  include_examples 'scan', '\g<+1>(abc)',       0 => [:backref, :number_rel_call_ab,      '\g<+1>',     0, 6]
+  include_examples 'scan', "\\g'+1'(abc)",      0 => [:backref, :number_rel_call_sq,      "\\g'+1'",    0, 6]
+
+  # Group back-references, with recursion level
+  include_examples 'scan', '(?<X>abc)\k<X-0>',  3 => [:backref, :name_recursion_ref_ab,   '\k<X-0>',    9, 16]
+  include_examples 'scan', "(?<X>abc)\\k'X-0'", 3 => [:backref, :name_recursion_ref_sq,   "\\k'X-0'",   9, 16]
+
+  include_examples 'scan', '(abc)\k<1-0>',      3 => [:backref, :number_recursion_ref_ab, '\k<1-0>',    5, 12]
+  include_examples 'scan', "(abc)\\k'1-0'",     3 => [:backref, :number_recursion_ref_sq, "\\k'1-0'",   5, 12]
 end

data/spec/scanner/sets_spec.rb

@@ -1,108 +1,94 @@
 require 'spec_helper'
 
 RSpec.describe('Set scanning') do
-  tests = {
-    '[a]'                   => [0, :set,    :open,            '[',          0, 1],
-    '[b]'                   => [2, :set,    :close,           ']',          2, 3],
-    '[^n]'                  => [1, :set,    :negate,          '^',          1, 2],
-
-    '[c]'                   => [1, :literal, :literal,        'c',          1, 2],
-    '[\b]'                  => [1, :escape,  :backspace,      '\b',         1, 3],
-    '[A\bX]'                => [2, :escape,  :backspace,      '\b',         2, 4],
-
-    '[.]'                   => [1, :literal, :literal,        '.',          1, 2],
-    '[?]'                   => [1, :literal, :literal,        '?',          1, 2],
-    '[*]'                   => [1, :literal, :literal,        '*',          1, 2],
-    '[+]'                   => [1, :literal, :literal,        '+',          1, 2],
-    '[{]'                   => [1, :literal, :literal,        '{',          1, 2],
-    '[}]'                   => [1, :literal, :literal,        '}',          1, 2],
-    '[<]'                   => [1, :literal, :literal,        '<',          1, 2],
-    '[>]'                   => [1, :literal, :literal,        '>',          1, 2],
-
-    '[äöü]'                 => [2, :literal, :literal,        'ö',          3, 5],
-
-    '[\x20]'                => [1, :escape, :hex,             '\x20',       1, 5],
-
-    '[\.]'                  => [1, :escape, :dot,             '\.',         1, 3],
-    '[\!]'                  => [1, :escape, :literal,         '\!',         1, 3],
-    '[\#]'                  => [1, :escape, :literal,         '\#',         1, 3],
-    '[\]]'                  => [1, :escape, :set_close,       '\]',         1, 3],
-    '[\\\]'                 => [1, :escape, :backslash,       '\\\\',       1, 3],
-    '[\A]'                  => [1, :escape, :literal,         '\A',         1, 3],
-    '[\z]'                  => [1, :escape, :literal,         '\z',         1, 3],
-    '[\g]'                  => [1, :escape, :literal,         '\g',         1, 3],
-    '[\K]'                  => [1, :escape, :literal,         '\K',         1, 3],
-    '[\c2]'                 => [1, :escape, :literal,         '\c',         1, 3],
-    '[\B]'                  => [1, :escape, :literal,         '\B',         1, 3],
-    '[a\-c]'                => [2, :escape, :literal,         '\-',         2, 4],
-
-    '[\d]'                  => [1, :type,   :digit,           '\d',         1, 3],
-    '[\da-z]'               => [1, :type,   :digit,           '\d',         1, 3],
-    '[\D]'                  => [1, :type,   :nondigit,        '\D',         1, 3],
-
-    '[\h]'                  => [1, :type,   :hex,             '\h',         1, 3],
-    '[\H]'                  => [1, :type,   :nonhex,          '\H',         1, 3],
-
-    '[\s]'                  => [1, :type,   :space,           '\s',         1, 3],
-    '[\S]'                  => [1, :type,   :nonspace,        '\S',         1, 3],
-
-    '[\w]'                  => [1, :type,   :word,            '\w',         1, 3],
-    '[\W]'                  => [1, :type,   :nonword,         '\W',         1, 3],
-
-    '[\R]'                  => [1, :escape, :literal,         '\R',         1, 3],
-    '[\X]'                  => [1, :escape, :literal,         '\X',         1, 3],
-
-    '[a-b]'                 => [1, :literal, :literal,        'a',          1, 2],
-    '[a-c]'                 => [2, :set,     :range,          '-',          2, 3],
-    '[a-d]'                 => [3, :literal, :literal,        'd',          3, 4],
-    '[a-b-]'                => [4, :literal, :literal,        '-',          4, 6],
-    '[-a]'                  => [1, :literal, :literal,        '-',          1, 2],
-    '[a-c^]'                => [4, :literal, :literal,        '^',          4, 5],
-    '[a-bd-f]'              => [2, :set,    :range,           '-',          2, 3],
-    '[a-cd-f]'              => [5, :set,    :range,           '-',          5, 6],
-
-    '[a[:digit:]c]'         => [2, :posixclass,    :digit,    '[:digit:]',  2, 11],
-    '[[:digit:][:space:]]'  => [2, :posixclass,    :space,    '[:space:]', 10, 19],
-    '[[:^digit:]]'          => [1, :nonposixclass, :digit,    '[:^digit:]', 1, 11],
-
-    '[a[.a-b.]c]'           => [2, :set,    :collation,       '[.a-b.]',    2,  9],
-    '[a[=e=]c]'             => [2, :set,    :equivalent,      '[=e=]',      2,  7],
-
-    '[a-d&&g-h]'            => [4, :set,    :intersection,    '&&',         4, 6],
-    '[a&&]'                 => [2, :set,    :intersection,    '&&',         2, 4],
-    '[&&z]'                 => [1, :set,    :intersection,    '&&',         1, 3],
-
-    '[\\x20-\\x27]'         => [1, :escape, :hex,             '\x20',       1, 5],
-    '[\\x20-\\x28]'         => [2, :set,    :range,           '-',          5, 6],
-    '[\\x20-\\x29]'         => [3, :escape, :hex,             '\x29',       6, 10],
-
-    '[a\p{digit}c]'         => [2, :property,    :digit,      '\p{digit}',  2, 11],
-    '[a\P{digit}c]'         => [2, :nonproperty, :digit,      '\P{digit}',  2, 11],
-    '[a\p{^digit}c]'        => [2, :nonproperty, :digit,      '\p{^digit}', 2, 12],
-    '[a\P{^digit}c]'        => [2, :property,    :digit,      '\P{^digit}', 2, 12],
-
-    '[a\p{ALPHA}c]'         => [2, :property,    :alpha,      '\p{ALPHA}',  2, 11],
-    '[a\p{P}c]'             => [2, :property,    :punctuation,'\p{P}',      2, 7],
-    '[a\p{P}\P{P}c]'        => [3, :nonproperty, :punctuation,'\P{P}',      7, 12],
-
-    '[a-w&&[^c-g]z]'        => [5, :set,    :open,            '[',          6, 7],
-    '[a-w&&[^c-h]z]'        => [6, :set,    :negate,          '^',          7, 8],
-    '[a-w&&[^c-i]z]'        => [8, :set,    :range,           '-',          9, 10],
-    '[a-w&&[^c-j]z]'        => [10,:set,    :close,           ']',          11, 12],
-  }
-
-  tests.each_with_index do |(pattern, (index, type, token, text, ts, te)), count|
-    specify("scanner_#{type}_#{token}_in_'#{pattern}'_#{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', /[a]/,                   0 => [:set,    :open,            '[',          0, 1]
+  include_examples 'scan', /[b]/,                   2 => [:set,    :close,           ']',          2, 3]
+  include_examples 'scan', /[^n]/,                  1 => [:set,    :negate,          '^',          1, 2]
+
+  include_examples 'scan', /[c]/,                   1 => [:literal, :literal,        'c',          1, 2]
+  include_examples 'scan', /[\b]/,                  1 => [:escape,  :backspace,      '\b',         1, 3]
+  include_examples 'scan', /[A\bX]/,                2 => [:escape,  :backspace,      '\b',         2, 4]
+
+  include_examples 'scan', /[.]/,                   1 => [:literal, :literal,        '.',          1, 2]
+  include_examples 'scan', /[?]/,                   1 => [:literal, :literal,        '?',          1, 2]
+  include_examples 'scan', /[*]/,                   1 => [:literal, :literal,        '*',          1, 2]
+  include_examples 'scan', /[+]/,                   1 => [:literal, :literal,        '+',          1, 2]
+  include_examples 'scan', /[{]/,                   1 => [:literal, :literal,        '{',          1, 2]
+  include_examples 'scan', /[}]/,                   1 => [:literal, :literal,        '}',          1, 2]
+  include_examples 'scan', /[<]/,                   1 => [:literal, :literal,        '<',          1, 2]
+  include_examples 'scan', /[>]/,                   1 => [:literal, :literal,        '>',          1, 2]
+
+  include_examples 'scan', /[äöü]/,                 2 => [:literal, :literal,        'ö',          3, 5]
+
+  include_examples 'scan', /[\x20]/,                1 => [:escape, :hex,             '\x20',       1, 5]
+
+  include_examples 'scan', '[\.]',                  1 => [:escape, :dot,             '\.',         1, 3]
+  include_examples 'scan', '[\!]',                  1 => [:escape, :literal,         '\!',         1, 3]
+  include_examples 'scan', '[\#]',                  1 => [:escape, :literal,         '\#',         1, 3]
+  include_examples 'scan', '[\\]]',                 1 => [:escape, :set_close,       '\]',         1, 3]
+  include_examples 'scan', '[\\\\]',                1 => [:escape, :backslash,       '\\\\',       1, 3]
+  include_examples 'scan', '[\A]',                  1 => [:escape, :literal,         '\A',         1, 3]
+  include_examples 'scan', '[\z]',                  1 => [:escape, :literal,         '\z',         1, 3]
+  include_examples 'scan', '[\g]',                  1 => [:escape, :literal,         '\g',         1, 3]
+  include_examples 'scan', '[\K]',                  1 => [:escape, :literal,         '\K',         1, 3]
+  include_examples 'scan', '[\R]',                  1 => [:escape, :literal,         '\R',         1, 3]
+  include_examples 'scan', '[\X]',                  1 => [:escape, :literal,         '\X',         1, 3]
+  include_examples 'scan', '[\c2]',                 1 => [:escape, :literal,         '\c',         1, 3]
+  include_examples 'scan', '[\B]',                  1 => [:escape, :literal,         '\B',         1, 3]
+  include_examples 'scan', '[a\-c]',                2 => [:escape, :literal,         '\-',         2, 4]
+
+  include_examples 'scan', /[\d]/,                  1 => [:type,   :digit,           '\d',         1, 3]
+  include_examples 'scan', /[\da-z]/,               1 => [:type,   :digit,           '\d',         1, 3]
+  include_examples 'scan', /[\D]/,                  1 => [:type,   :nondigit,        '\D',         1, 3]
+
+  include_examples 'scan', /[\h]/,                  1 => [:type,   :hex,             '\h',         1, 3]
+  include_examples 'scan', /[\H]/,                  1 => [:type,   :nonhex,          '\H',         1, 3]
+
+  include_examples 'scan', /[\s]/,                  1 => [:type,   :space,           '\s',         1, 3]
+  include_examples 'scan', /[\S]/,                  1 => [:type,   :nonspace,        '\S',         1, 3]
+
+  include_examples 'scan', /[\w]/,                  1 => [:type,   :word,            '\w',         1, 3]
+  include_examples 'scan', /[\W]/,                  1 => [:type,   :nonword,         '\W',         1, 3]
+
+  include_examples 'scan', /[a-b]/,                 1 => [:literal, :literal,        'a',          1, 2]
+  include_examples 'scan', /[a-c]/,                 2 => [:set,     :range,          '-',          2, 3]
+  include_examples 'scan', /[a-d]/,                 3 => [:literal, :literal,        'd',          3, 4]
+  include_examples 'scan', /[a-b-]/,                4 => [:literal, :literal,        '-',          4, 5]
+  include_examples 'scan', /[-a]/,                  1 => [:literal, :literal,        '-',          1, 2]
+  include_examples 'scan', /[a-c^]/,                4 => [:literal, :literal,        '^',          4, 5]
+  include_examples 'scan', /[a-bd-f]/,              2 => [:set,    :range,           '-',          2, 3]
+  include_examples 'scan', /[a-cd-f]/,              5 => [:set,    :range,           '-',          5, 6]
+
+  include_examples 'scan', /[a[:digit:]c]/,         2 => [:posixclass,    :digit,    '[:digit:]',  2, 11]
+  include_examples 'scan', /[[:digit:][:space:]]/,  2 => [:posixclass,    :space,    '[:space:]', 10, 19]
+  include_examples 'scan', /[[:^digit:]]/,          1 => [:nonposixclass, :digit,    '[:^digit:]', 1, 11]
+
+  include_examples 'scan', /[a[.a-b.]c]/,           2 => [:set,    :collation,       '[.a-b.]',    2,  9]
+  include_examples 'scan', /[a[=e=]c]/,             2 => [:set,    :equivalent,      '[=e=]',      2,  7]
+
+  include_examples 'scan', /[a-d&&g-h]/,            4 => [:set,    :intersection,    '&&',         4, 6]
+  include_examples 'scan', /[a&&]/,                 2 => [:set,    :intersection,    '&&',         2, 4]
+  include_examples 'scan', /[&&z]/,                 1 => [:set,    :intersection,    '&&',         1, 3]
+
+  include_examples 'scan', /[a\p{digit}c]/,         2 => [:property,    :digit,      '\p{digit}',  2, 11]
+  include_examples 'scan', /[a\P{digit}c]/,         2 => [:nonproperty, :digit,      '\P{digit}',  2, 11]
+  include_examples 'scan', /[a\p{^digit}c]/,        2 => [:nonproperty, :digit,      '\p{^digit}', 2, 12]
+  include_examples 'scan', /[a\P{^digit}c]/,        2 => [:property,    :digit,      '\P{^digit}', 2, 12]
+
+  include_examples 'scan', /[a\p{ALPHA}c]/,         2 => [:property,    :alpha,      '\p{ALPHA}',  2, 11]
+  include_examples 'scan', /[a\p{P}c]/,             2 => [:property,    :punctuation,'\p{P}',      2, 7]
+  include_examples 'scan', /[a\p{P}\P{P}c]/,        3 => [:nonproperty, :punctuation,'\P{P}',      7, 12]
+
+  include_examples 'scan', /[\x20-\x27]/,
+    1 => [:escape, :hex,             '\x20',       1, 5],
+    2 => [:set,    :range,           '-',          5, 6],
+    3 => [:escape, :hex,             '\x27',       6, 10]
+
+  include_examples 'scan', /[a-w&&[^c-g]z]/,
+    5 => [:set,    :open,            '[',          6, 7],
+    6 => [:set,    :negate,          '^',          7, 8],
+    8 => [:set,    :range,           '-',          9, 10],
+    10=> [:set,    :close,           ']',          11, 12]
 
   specify('set literal encoding') do
     text = RS.scan('[a]')[1][2].to_s

data/spec/scanner/types_spec.rb

@@ -1,29 +1,14 @@
 require 'spec_helper'
 
 RSpec.describe('Type scanning') do
-  tests = {
-    'a\\dc' => [1, :type, :digit, '\\d', 1, 3],
-    'a\\Dc' => [1, :type, :nondigit, '\\D', 1, 3],
-    'a\\hc' => [1, :type, :hex, '\\h', 1, 3],
-    'a\\Hc' => [1, :type, :nonhex, '\\H', 1, 3],
-    'a\\sc' => [1, :type, :space, '\\s', 1, 3],
-    'a\\Sc' => [1, :type, :nonspace, '\\S', 1, 3],
-    'a\\wc' => [1, :type, :word, '\\w', 1, 3],
-    'a\\Wc' => [1, :type, :nonword, '\\W', 1, 3],
-    'a\\Rc' => [1, :type, :linebreak, '\\R', 1, 3],
-    'a\\Xc' => [1, :type, :xgrapheme, '\\X', 1, 3],
-  }
-
-  tests.each do |(pattern, (index, type, token, text, ts, te))|
-    specify("scanner_#{type}_#{token}") 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', 'a\\dc', 1 => [:type, :digit,     '\\d', 1, 3]
+  include_examples 'scan', 'a\\Dc', 1 => [:type, :nondigit,  '\\D', 1, 3]
+  include_examples 'scan', 'a\\hc', 1 => [:type, :hex,       '\\h', 1, 3]
+  include_examples 'scan', 'a\\Hc', 1 => [:type, :nonhex,    '\\H', 1, 3]
+  include_examples 'scan', 'a\\sc', 1 => [:type, :space,     '\\s', 1, 3]
+  include_examples 'scan', 'a\\Sc', 1 => [:type, :nonspace,  '\\S', 1, 3]
+  include_examples 'scan', 'a\\wc', 1 => [:type, :word,      '\\w', 1, 3]
+  include_examples 'scan', 'a\\Wc', 1 => [:type, :nonword,   '\\W', 1, 3]
+  include_examples 'scan', 'a\\Rc', 1 => [:type, :linebreak, '\\R', 1, 3]
+  include_examples 'scan', 'a\\Xc', 1 => [:type, :xgrapheme, '\\X', 1, 3]
 end

data/spec/spec_helper.rb

@@ -1,5 +1,6 @@
 require 'regexp_parser'
 require 'regexp_property_values'
+require_relative 'support/shared_examples'
 
 RS = Regexp::Scanner
 RL = Regexp::Lexer

data/spec/support/shared_examples.rb

@@ -0,0 +1,77 @@
+RSpec.shared_examples 'syntax' do |klass, opts|
+  opts[:implements].each do |type, tokens|
+    tokens.each do |token|
+      it("implements #{token} #{type}") do
+        expect(klass.implements?(type, token)).to be true
+      end
+    end
+  end
+
+  opts[:excludes] && opts[:excludes].each do |type, tokens|
+    tokens.each do |token|
+      it("does not implement #{token} #{type}") do
+        expect(klass.implements?(type, token)).to be false
+      end
+    end
+  end
+end
+
+RSpec.shared_examples 'scan' do |pattern, checks|
+  context "given the pattern #{pattern}" do
+    before(:all) { @tokens = Regexp::Scanner.scan(pattern) }
+
+    checks.each do |index, (type, token, text, ts, te)|
+      it "scans token #{index} as #{token} #{type} at #{ts}..#{te}" do
+        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
+  end
+end
+
+RSpec.shared_examples 'lex' do |pattern, checks|
+  context "given the pattern #{pattern}" do
+    before(:all) { @tokens = Regexp::Lexer.lex(pattern) }
+
+    checks.each do |index, (type, token, text, ts, te, lvl, set_lvl, cond_lvl)|
+      it "lexes token #{index} as #{token} #{type} at #{lvl}, #{set_lvl}, #{cond_lvl}" do
+        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 lvl
+        expect(struct.set_level).to eq set_lvl
+        expect(struct.conditional_level).to eq cond_lvl
+      end
+    end
+  end
+end
+
+RSpec.shared_examples 'parse' do |pattern, checks|
+  context "given the pattern #{pattern}" do
+    before(:all) { @root = Regexp::Parser.parse(pattern, '*') }
+
+    checks.each do |path, (type, token, klass, attributes)|
+      it "parses expression at #{path} as #{klass}" do
+        exp = @root.dig(*path)
+
+        expect(exp).to be_instance_of(klass)
+        expect(exp.type).to eq type
+        expect(exp.token).to eq token
+
+        attributes && attributes.each do |method, value|
+          expect(exp.send(method)).to eq(value),
+            "expected expression at #{path} to have #{method} #{value}"
+        end
+      end
+    end
+  end
+end