regexp_parser 1.5.0 → 1.5.1

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

data/spec/scanner/errors_spec.rb

@@ -1,90 +1,68 @@
 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, 'unbalanced interval', 'a{1,2'
+  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