regexp_parser 1.3.0 → 1.6.0

data/spec/lexer/all_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+RSpec.describe(Regexp::Lexer) do
+  specify('lexer returns an array') do
+    expect(RL.lex('abc')).to be_instance_of(Array)
+  end
+
+  specify('lexer returns tokens') do
+    tokens = RL.lex('^abc+[^one]{2,3}\\b\\d\\\\C-C$')
+    expect(tokens).to all(be_a Regexp::Token)
+    expect(tokens.map { |token| token.to_a.length }).to all(eq 8)
+  end
+
+  specify('lexer token count') do
+    tokens = RL.lex(/^(one|two){2,3}([^d\]efm-qz\,\-]*)(ghi)+$/i)
+    expect(tokens.length).to eq 28
+  end
+
+  specify('lexer scan alias') do
+    expect(RL.scan(/a|b|c/)).to eq RL.lex(/a|b|c/)
+  end
+end

data/spec/lexer/conditionals_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+
+RSpec.describe('Conditional lexing') do
+  include_examples 'lex', /(?<A>a)(?(<A>)b|c)/,
+    3 => [:conditional, :open,       '(?',     7,  9, 0, 0, 0],
+    4 => [:conditional, :condition,  '(<A>)',  9, 14, 0, 0, 1],
+    6 => [:conditional, :separator,  '|',     15, 16, 0, 0, 1],
+    8 => [:conditional, :close,      ')',     17, 18, 0, 0, 0]
+
+  include_examples 'lex', /((?<A>a)(?<B>(?(<A>)b|((?(<B>)[e-g]|[h-j])))))/,
+     0 => [:group,       :capture,     '(',       0,  1, 0, 0, 0],
+     1 => [:group,       :named,       '(?<A>',   1,  6, 1, 0, 0],
+     5 => [:conditional, :open,        '(?',     13, 15, 2, 0, 0],
+     6 => [:conditional, :condition,   '(<A>)',  15, 20, 2, 0, 1],
+     8 => [:conditional, :separator,   '|',      21, 22, 2, 0, 1],
+    10 => [:conditional, :open,        '(?',     23, 25, 3, 0, 1],
+    11 => [:conditional, :condition,   '(<B>)',  25, 30, 3, 0, 2],
+    12 => [:set,         :open,        '[',      30, 31, 3, 0, 2],
+    13 => [:literal,     :literal,     'e',      31, 32, 3, 1, 2],
+    14 => [:set,         :range,       '-',      32, 33, 3, 1, 2],
+    15 => [:literal,     :literal,     'g',      33, 34, 3, 1, 2],
+    16 => [:set,         :close,       ']',      34, 35, 3, 0, 2],
+    17 => [:conditional, :separator,   '|',      35, 36, 3, 0, 2],
+    23 => [:conditional, :close,       ')',      41, 42, 3, 0, 1],
+    25 => [:conditional, :close,       ')',      43, 44, 2, 0, 0],
+    26 => [:group,       :close,       ')',      44, 45, 1, 0, 0],
+    27 => [:group,       :close,       ')',      45, 46, 0, 0, 0]
+
+  include_examples 'lex', /(a(b(c)))(?(1)(?(2)(?(3)d|e))|(?(3)(?(2)f|g)|(?(1)f|g)))/,
+     9 => [:conditional, :open,       '(?',    9, 11, 0, 0, 0],
+    10 => [:conditional, :condition,  '(1)',  11, 14, 0, 0, 1],
+    11 => [:conditional, :open,       '(?',   14, 16, 0, 0, 1],
+    12 => [:conditional, :condition,  '(2)',  16, 19, 0, 0, 2],
+    13 => [:conditional, :open,       '(?',   19, 21, 0, 0, 2],
+    14 => [:conditional, :condition,  '(3)',  21, 24, 0, 0, 3],
+    16 => [:conditional, :separator,  '|',    25, 26, 0, 0, 3],
+    18 => [:conditional, :close,      ')',    27, 28, 0, 0, 2],
+    19 => [:conditional, :close,      ')',    28, 29, 0, 0, 1],
+    20 => [:conditional, :separator,  '|',    29, 30, 0, 0, 1],
+    21 => [:conditional, :open,       '(?',   30, 32, 0, 0, 1],
+    22 => [:conditional, :condition,  '(3)',  32, 35, 0, 0, 2],
+    23 => [:conditional, :open,       '(?',   35, 37, 0, 0, 2],
+    24 => [:conditional, :condition,  '(2)',  37, 40, 0, 0, 3],
+    26 => [:conditional, :separator,  '|',    41, 42, 0, 0, 3],
+    28 => [:conditional, :close,      ')',    43, 44, 0, 0, 2],
+    29 => [:conditional, :separator,  '|',    44, 45, 0, 0, 2],
+    30 => [:conditional, :open,       '(?',   45, 47, 0, 0, 2],
+    31 => [:conditional, :condition,  '(1)',  47, 50, 0, 0, 3],
+    33 => [:conditional, :separator,  '|',    51, 52, 0, 0, 3],
+    35 => [:conditional, :close,      ')',    53, 54, 0, 0, 2],
+    36 => [:conditional, :close,      ')',    54, 55, 0, 0, 1],
+    37 => [:conditional, :close,      ')',    55, 56, 0, 0, 0]
+end

data/spec/lexer/escapes_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+RSpec.describe('Escape lexing') do
+  include_examples 'lex', '\u{62}',
+    0 => [:escape,  :codepoint_list, '\u{62}',       0, 6,  0, 0, 0]
+
+  include_examples 'lex', '\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}',  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

@@ -0,0 +1,10 @@
+require 'spec_helper'
+
+RSpec.describe('Keep lexing') do
+  include_examples 'lex', /ab\Kcd/,
+    1 => [:keep, :mark, '\K', 2,  4,  0, 0, 0]
+
+  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

@@ -0,0 +1,89 @@
+require 'spec_helper'
+
+RSpec.describe('Literal lexing') do
+  # 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.count).to eq 2
+  end
+
+  specify('lex single 3 byte char') do
+    tokens = RL.lex("\u308C+")
+    expect(tokens.count).to eq 2
+  end
+
+  specify('lex single 4 byte char') do
+    tokens = RL.lex("\u{1D11E}+")
+    expect(tokens.count).to eq 2
+  end
+end

data/spec/lexer/nesting_spec.rb

@@ -0,0 +1,99 @@
+require 'spec_helper'
+
+RSpec.describe('Nesting lexing') do
+  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]
+
+  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]
+
+  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]
+
+  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]
+
+  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]
+
+  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]
+
+  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]
+
+  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]
+
+  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]
+
+  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

data/spec/lexer/refcalls_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+
+RSpec.describe('RefCall lexing') do
+  # Traditional numerical group back-reference
+  include_examples 'lex', '(abc)\1',
+    3 => [:backref, :number,                '\1',         5,  7, 0, 0, 0]
+
+  # Group back-references, named, numbered, and relative
+  include_examples 'lex', '(?<X>abc)\k<X>',
+    3 => [:backref, :name_ref,              '\k<X>',      9, 14, 0, 0, 0]
+  include_examples 'lex', "(?<X>abc)\\k'X'",
+    3 => [:backref, :name_ref,              "\\k'X'",     9, 14, 0, 0, 0]
+
+  include_examples 'lex', '(abc)\k<1>',
+    3 => [:backref, :number_ref,            '\k<1>',      5, 10, 0, 0, 0]
+  include_examples 'lex', "(abc)\\k'1'",
+    3 => [:backref, :number_ref,            "\\k'1'",     5, 10, 0, 0, 0]
+
+  include_examples 'lex', '(abc)\k<-1>',
+    3 => [:backref, :number_rel_ref,        '\k<-1>',     5, 11, 0, 0, 0]
+  include_examples 'lex', "(abc)\\k'-1'",
+    3 => [:backref, :number_rel_ref,        "\\k'-1'",    5, 11, 0, 0, 0]
+
+  # Sub-expression invocation, named, numbered, and relative
+  include_examples 'lex', '(?<X>abc)\g<X>',
+    3 => [:backref, :name_call,             '\g<X>',      9, 14, 0, 0, 0]
+  include_examples 'lex', "(?<X>abc)\\g'X'",
+    3 => [:backref, :name_call,             "\\g'X'",     9, 14, 0, 0, 0]
+
+  include_examples 'lex', '(abc)\g<1>',
+    3 => [:backref, :number_call,           '\g<1>',      5, 10, 0, 0, 0]
+  include_examples 'lex', "(abc)\\g'1'",
+    3 => [:backref, :number_call,           "\\g'1'",     5, 10, 0, 0, 0]
+
+  include_examples 'lex', '(abc)\g<-1>',
+    3 => [:backref, :number_rel_call,       '\g<-1>',     5, 11, 0, 0, 0]
+  include_examples 'lex', "(abc)\\g'-1'",
+    3 => [:backref, :number_rel_call,       "\\g'-1'",    5, 11, 0, 0, 0]
+
+  include_examples 'lex', '(abc)\g<+1>',
+    3 => [:backref, :number_rel_call,       '\g<+1>',     5, 11, 0, 0, 0]
+  include_examples 'lex', "(abc)\\g'+1'",
+    3 => [:backref, :number_rel_call,       "\\g'+1'",    5, 11, 0, 0, 0]
+
+  # Group back-references, with nesting level
+  include_examples 'lex', '(?<X>abc)\k<X-0>',
+    3 => [:backref, :name_recursion_ref,    '\k<X-0>',    9, 16, 0, 0, 0]
+  include_examples 'lex', "(?<X>abc)\\k'X-0'",
+    3 => [:backref, :name_recursion_ref,    "\\k'X-0'",   9, 16, 0, 0, 0]
+
+  include_examples 'lex', '(abc)\k<1-0>',
+    3 => [:backref, :number_recursion_ref,  '\k<1-0>',    5, 12, 0, 0, 0]
+  include_examples 'lex', "(abc)\\k'1-0'",
+    3 => [:backref, :number_recursion_ref,  "\\k'1-0'",   5, 12, 0, 0, 0]
+end

data/spec/parser/all_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+RSpec.describe(Regexp::Parser) do
+  specify('parse returns a root expression') do
+    expect(RP.parse('abc')).to be_instance_of(Root)
+  end
+
+  specify('parse can be called with block') do
+    expect(RP.parse('abc') { |root| root.class }).to eq Root
+  end
+
+  specify('parse root contains expressions') do
+    root = RP.parse(/^a.c+[^one]{2,3}\b\d\\\C-C$/)
+    expect(root.expressions).to all(be_a Regexp::Expression::Base)
+  end
+
+  specify('parse root options mi') do
+    root = RP.parse(/[abc]/mi, 'ruby/1.8')
+
+    expect(root.m?).to be true
+    expect(root.i?).to be true
+    expect(root.x?).to be false
+  end
+
+  specify('parse node types') do
+    root = RP.parse('^(one){2,3}([^d\\]efm-qz\\,\\-]*)(ghi)+$')
+
+    expect(root[1][0]).to be_a(Literal)
+    expect(root[1]).to be_quantified
+    expect(root[2][0]).to be_a(CharacterSet)
+    expect(root[2]).not_to be_quantified
+    expect(root[3]).to be_a(Group::Capture)
+    expect(root[3]).to be_quantified
+  end
+
+  specify('parse no quantifier target raises error') do
+    expect { RP.parse('?abc') }.to raise_error(ArgumentError)
+  end
+
+  specify('parse sequence no quantifier target raises error') do
+    expect { RP.parse('abc|?def') }.to raise_error(ArgumentError)
+  end
+end

data/spec/parser/alternation_spec.rb

@@ -0,0 +1,88 @@
+require 'spec_helper'
+
+RSpec.describe('Alternation parsing') do
+  let(:root) { RP.parse('(ab??|cd*|ef+)*|(gh|ij|kl)?') }
+
+  specify('parse alternation root') do
+    e = root[0]
+    expect(e).to be_a(Alternation)
+  end
+
+  specify('parse alternation alts') do
+    alts = root[0].alternatives
+
+    expect(alts[0]).to be_a(Alternative)
+    expect(alts[1]).to be_a(Alternative)
+
+    expect(alts[0][0]).to be_a(Group::Capture)
+    expect(alts[1][0]).to be_a(Group::Capture)
+
+    expect(alts.length).to eq 2
+  end
+
+  specify('parse alternation nested') do
+    e = root[0].alternatives[0][0][0]
+
+    expect(e).to be_a(Alternation)
+  end
+
+  specify('parse alternation nested sequence') do
+    alts = root[0][0]
+    nested = alts[0][0][0]
+
+    expect(nested).to be_a(Alternative)
+
+    expect(nested[0]).to be_a(Literal)
+    expect(nested[1]).to be_a(Literal)
+    expect(nested.expressions.length).to eq 2
+  end
+
+  specify('parse alternation nested groups') do
+    root = RP.parse('(i|ey|([ougfd]+)|(ney))')
+
+    alts = root[0][0].alternatives
+    expect(alts.length).to eq 4
+  end
+
+  specify('parse alternation grouped alts') do
+    root = RP.parse('ca((n)|(t)|(ll)|(b))')
+
+    alts = root[1][0].alternatives
+
+    expect(alts.length).to eq 4
+
+    expect(alts[0]).to be_a(Alternative)
+    expect(alts[1]).to be_a(Alternative)
+    expect(alts[2]).to be_a(Alternative)
+    expect(alts[3]).to be_a(Alternative)
+  end
+
+  specify('parse alternation nested grouped alts') do
+    root = RP.parse('ca((n|t)|(ll|b))')
+
+    alts = root[1][0].alternatives
+
+    expect(alts.length).to eq 2
+
+    expect(alts[0]).to be_a(Alternative)
+    expect(alts[1]).to be_a(Alternative)
+
+    subalts = root[1][0][0][0][0].alternatives
+
+    expect(alts.length).to eq 2
+
+    expect(subalts[0]).to be_a(Alternative)
+    expect(subalts[1]).to be_a(Alternative)
+  end
+
+  specify('parse alternation continues after nesting') do
+    root = RP.parse(/a|(b)c/)
+
+    seq = root[0][1].expressions
+
+    expect(seq.length).to eq 2
+
+    expect(seq[0]).to be_a(Group::Capture)
+    expect(seq[1]).to be_a(Literal)
+  end
+end