regexp_parser 1.5.0 → 1.5.1

data/spec/parser/all_spec.rb

@@ -2,7 +2,11 @@ require 'spec_helper'
 
 RSpec.describe(Regexp::Parser) do
   specify('parse returns a root expression') do
-    expect(RP.parse('abc')).to be_instance_of(Regexp::Expression::Root)
+    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
@@ -10,6 +14,14 @@ RSpec.describe(Regexp::Parser) do
     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)+$')
 

data/spec/parser/anchors_spec.rb

@@ -1,31 +1,17 @@
 require 'spec_helper'
 
 RSpec.describe('Anchor parsing') do
-  tests = {
-    '^a'      => [0, :anchor,   :bol,                 Anchor::BOL],
-    'a$'      => [1, :anchor,   :eol,                 Anchor::EOL],
+  include_examples 'parse', /^a/,   0 =>  [:anchor,   :bol,               Anchor::BOL]
+  include_examples 'parse', /a$/,   1 =>  [:anchor,   :eol,               Anchor::EOL]
 
-    '\Aa'     => [0, :anchor,   :bos,                 Anchor::BOS],
-    'a\z'     => [1, :anchor,   :eos,                 Anchor::EOS],
-    'a\Z'     => [1, :anchor,   :eos_ob_eol,          Anchor::EOSobEOL],
+  include_examples 'parse', /\Aa/,  0 =>  [:anchor,   :bos,               Anchor::BOS]
+  include_examples 'parse', /a\z/,  1 =>  [:anchor,   :eos,               Anchor::EOS]
+  include_examples 'parse', /a\Z/,  1 =>  [:anchor,   :eos_ob_eol,        Anchor::EOSobEOL]
 
-    'a\b'     => [1, :anchor,   :word_boundary,       Anchor::WordBoundary],
-    'a\B'     => [1, :anchor,   :nonword_boundary,    Anchor::NonWordBoundary],
+  include_examples 'parse', /a\b/,  1 =>  [:anchor,   :word_boundary,     Anchor::WordBoundary]
+  include_examples 'parse', /a\B/,  1 =>  [:anchor,   :nonword_boundary,  Anchor::NonWordBoundary]
 
-    'a\G'     => [1, :anchor,   :match_start,         Anchor::MatchStart],
+  include_examples 'parse', /a\G/,  1 =>  [:anchor,   :match_start,       Anchor::MatchStart]
 
-    "\\\\Aa"  => [0, :escape,   :backslash,           EscapeSequence::Literal],
-  }
-
-  tests.each_with_index do |(pattern, (index, type, token, klass)), count|
-    specify("parse_anchor_#{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
+  include_examples 'parse', /\\A/,  0 =>  [:escape,   :backslash,         EscapeSequence::Literal]
 end

data/spec/parser/conditionals_spec.rb

@@ -2,7 +2,7 @@ require 'spec_helper'
 
 RSpec.describe('Conditional parsing') do
   specify('parse conditional') do
-    regexp = Regexp.new('(?<A>a)(?(<A>)T|F)/')
+    regexp = /(?<A>a)(?(<A>)T|F)/
 
     root = RP.parse(regexp, 'ruby/2.0')
     exp = root[1]
@@ -16,7 +16,7 @@ RSpec.describe('Conditional parsing') do
   end
 
   specify('parse conditional condition') do
-    regexp = Regexp.new('(?<A>a)(?(<A>)T|F)/')
+    regexp = /(?<A>a)(?(<A>)T|F)/
 
     root = RP.parse(regexp, 'ruby/2.0')
     exp = root[1].condition
@@ -31,7 +31,7 @@ RSpec.describe('Conditional parsing') do
   end
 
   specify('parse conditional condition with number ref') do
-    regexp = Regexp.new('(a)(?(1)T|F)/')
+    regexp = /(a)(?(1)T|F)/
 
     root = RP.parse(regexp, 'ruby/2.0')
     exp = root[1].condition
@@ -46,7 +46,7 @@ RSpec.describe('Conditional parsing') do
   end
 
   specify('parse conditional nested groups') do
-    regexp = Regexp.new('((a)|(b)|((?(2)(c(d|e)+)?|(?(3)f|(?(4)(g|(h)(i)))))))/')
+    regexp = /((a)|(b)|((?(2)(c(d|e)+)?|(?(3)f|(?(4)(g|(h)(i)))))))/
 
     root = RP.parse(regexp, 'ruby/2.0')
 
@@ -80,7 +80,7 @@ RSpec.describe('Conditional parsing') do
   end
 
   specify('parse conditional nested') do
-    regexp = Regexp.new('(a(b(c(d)(e))))(?(1)(?(2)d|(?(3)e|f))|(?(4)(?(5)g|h)))/')
+    regexp = /(a(b(c(d)(e))))(?(1)(?(2)d|(?(3)e|f))|(?(4)(?(5)g|h)))/
 
     root = RP.parse(regexp, 'ruby/2.0')
 
@@ -102,7 +102,7 @@ RSpec.describe('Conditional parsing') do
   end
 
   specify('parse conditional nested alternation') do
-    regexp = Regexp.new('(a)(?(1)(b|c|d)|(e|f|g))(h)(?(2)(i|j|k)|(l|m|n))|o|p/')
+    regexp = /(a)(?(1)(b|c|d)|(e|f|g))(h)(?(2)(i|j|k)|(l|m|n))|o|p/
 
     root = RP.parse(regexp, 'ruby/2.0')
 
@@ -125,7 +125,7 @@ RSpec.describe('Conditional parsing') do
   end
 
   specify('parse conditional extra separator') do
-    regexp = Regexp.new('(?<A>a)(?(<A>)T|)/')
+    regexp = /(?<A>a)(?(<A>)T|)/
 
     root = RP.parse(regexp, 'ruby/2.0')
     branches = root[1].branches
@@ -146,7 +146,7 @@ RSpec.describe('Conditional parsing') do
   end
 
   specify('parse conditional quantified') do
-    regexp = Regexp.new('(foo)(?(1)\d|(\w)){42}/')
+    regexp = /(foo)(?(1)\d|(\w)){42}/
 
     root = RP.parse(regexp, 'ruby/2.0')
     conditional = root[1]
@@ -158,7 +158,7 @@ RSpec.describe('Conditional parsing') do
   end
 
   specify('parse conditional branch content quantified') do
-    regexp = Regexp.new('(foo)(?(1)\d{23}|(\w){42})/')
+    regexp = /(foo)(?(1)\d{23}|(\w){42})/
 
     root = RP.parse(regexp, 'ruby/2.0')
     conditional = root[1]

data/spec/parser/errors_spec.rb

@@ -1,51 +1,30 @@
 require 'spec_helper'
 
 RSpec.describe('Parsing errors') do
-  let(:rp) { Regexp::Parser.new }
-  before { rp.parse(/foo/) }
+  let(:parser) { Regexp::Parser.new }
+  before { parser.parse(/foo/) } # initializes ivars
 
-  specify('parser unknown token type') do
-    expect { rp.send(:parse_token, Regexp::Token.new(:foo, :bar)) }
+  it('raises UnknownTokenTypeError for unknown token types') do
+    expect { parser.send(:parse_token, Regexp::Token.new(:foo, :bar)) }
       .to raise_error(Regexp::Parser::UnknownTokenTypeError)
   end
 
-  specify('parser unknown set token') do
-    expect { rp.send(:parse_token, Regexp::Token.new(:set, :foo)) }
-      .to raise_error(Regexp::Parser::UnknownTokenError)
-  end
-
-  specify('parser unknown meta token') do
-    expect { rp.send(:parse_token, Regexp::Token.new(:meta, :foo)) }
-      .to raise_error(Regexp::Parser::UnknownTokenError)
-  end
-
-  specify('parser unknown character type token') do
-    expect { rp.send(:parse_token, Regexp::Token.new(:type, :foo)) }
-      .to raise_error(Regexp::Parser::UnknownTokenError)
-  end
-
-  specify('parser unknown unicode property token') do
-    expect { rp.send(:parse_token, Regexp::Token.new(:property, :foo)) }
-      .to raise_error(Regexp::Parser::UnknownTokenError)
-  end
-
-  specify('parser unknown unicode nonproperty token') do
-    expect { rp.send(:parse_token, Regexp::Token.new(:nonproperty, :foo)) }
-      .to raise_error(Regexp::Parser::UnknownTokenError)
-  end
-
-  specify('parser unknown anchor token') do
-    expect { rp.send(:parse_token, Regexp::Token.new(:anchor, :foo)) }
-      .to raise_error(Regexp::Parser::UnknownTokenError)
-  end
-
-  specify('parser unknown quantifier token') do
-    expect { rp.send(:parse_token, Regexp::Token.new(:quantifier, :foo)) }
-      .to raise_error(Regexp::Parser::UnknownTokenError)
-  end
-
-  specify('parser unknown group open token') do
-    expect { rp.send(:parse_token, Regexp::Token.new(:group, :foo)) }
-      .to raise_error(Regexp::Parser::UnknownTokenError)
-  end
+  RSpec.shared_examples 'UnknownTokenError' do |type, token|
+    it "raises for unkown tokens of type #{type}" do
+      expect { parser.send(:parse_token, Regexp::Token.new(type, :foo)) }
+        .to raise_error(Regexp::Parser::UnknownTokenError)
+    end
+  end
+
+  include_examples 'UnknownTokenError', :anchor
+  include_examples 'UnknownTokenError', :backref
+  include_examples 'UnknownTokenError', :conditional
+  include_examples 'UnknownTokenError', :free_space
+  include_examples 'UnknownTokenError', :group
+  include_examples 'UnknownTokenError', :meta
+  include_examples 'UnknownTokenError', :nonproperty
+  include_examples 'UnknownTokenError', :property
+  include_examples 'UnknownTokenError', :quantifier
+  include_examples 'UnknownTokenError', :set
+  include_examples 'UnknownTokenError', :type
 end

data/spec/parser/escapes_spec.rb

@@ -1,49 +1,35 @@
 require 'spec_helper'
 
-RSpec.describe('Escape parsing') do
-  tests = {
-    /a\ac/          => [1, :escape, :bell,              EscapeSequence::Bell],
-    /a\ec/          => [1, :escape, :escape,            EscapeSequence::AsciiEscape],
-    /a\fc/          => [1, :escape, :form_feed,         EscapeSequence::FormFeed],
-    /a\nc/          => [1, :escape, :newline,           EscapeSequence::Newline],
-    /a\rc/          => [1, :escape, :carriage,          EscapeSequence::Return],
-    /a\tc/          => [1, :escape, :tab,               EscapeSequence::Tab],
-    /a\vc/          => [1, :escape, :vertical_tab,      EscapeSequence::VerticalTab],
-
-    # meta character escapes
-    /a\.c/          => [1, :escape, :dot,               EscapeSequence::Literal],
-    /a\?c/          => [1, :escape, :zero_or_one,       EscapeSequence::Literal],
-    /a\*c/          => [1, :escape, :zero_or_more,      EscapeSequence::Literal],
-    /a\+c/          => [1, :escape, :one_or_more,       EscapeSequence::Literal],
-    /a\|c/          => [1, :escape, :alternation,       EscapeSequence::Literal],
-    /a\(c/          => [1, :escape, :group_open,        EscapeSequence::Literal],
-    /a\)c/          => [1, :escape, :group_close,       EscapeSequence::Literal],
-    /a\{c/          => [1, :escape, :interval_open,     EscapeSequence::Literal],
-    /a\}c/          => [1, :escape, :interval_close,    EscapeSequence::Literal],
-
-    # unicode escapes
-    /a\u0640/       => [1, :escape, :codepoint,         EscapeSequence::Codepoint],
-    /a\u{41 1F60D}/ => [1, :escape, :codepoint_list,    EscapeSequence::CodepointList],
-    /a\u{10FFFF}/   => [1, :escape, :codepoint_list,    EscapeSequence::CodepointList],
-
-     # hex escapes
-    /a\xFF/n        => [1, :escape, :hex,               EscapeSequence::Hex],
-
-    # octal escapes
-    /a\177/n        => [1, :escape, :octal,             EscapeSequence::Octal],
-  }
-
-  tests.each_with_index do |(pattern, (index, type, token, klass)), count|
-    specify("parse_escape_#{token}_#{count = (count + 1)}") 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
+RSpec.describe('EscapeSequence parsing') do
+  include_examples 'parse', /a\ac/,          1 => [:escape, :bell,              EscapeSequence::Bell]
+  include_examples 'parse', /a\ec/,          1 => [:escape, :escape,            EscapeSequence::AsciiEscape]
+  include_examples 'parse', /a\fc/,          1 => [:escape, :form_feed,         EscapeSequence::FormFeed]
+  include_examples 'parse', /a\nc/,          1 => [:escape, :newline,           EscapeSequence::Newline]
+  include_examples 'parse', /a\rc/,          1 => [:escape, :carriage,          EscapeSequence::Return]
+  include_examples 'parse', /a\tc/,          1 => [:escape, :tab,               EscapeSequence::Tab]
+  include_examples 'parse', /a\vc/,          1 => [:escape, :vertical_tab,      EscapeSequence::VerticalTab]
+
+  # meta character escapes
+  include_examples 'parse', /a\.c/,          1 => [:escape, :dot,               EscapeSequence::Literal]
+  include_examples 'parse', /a\?c/,          1 => [:escape, :zero_or_one,       EscapeSequence::Literal]
+  include_examples 'parse', /a\*c/,          1 => [:escape, :zero_or_more,      EscapeSequence::Literal]
+  include_examples 'parse', /a\+c/,          1 => [:escape, :one_or_more,       EscapeSequence::Literal]
+  include_examples 'parse', /a\|c/,          1 => [:escape, :alternation,       EscapeSequence::Literal]
+  include_examples 'parse', /a\(c/,          1 => [:escape, :group_open,        EscapeSequence::Literal]
+  include_examples 'parse', /a\)c/,          1 => [:escape, :group_close,       EscapeSequence::Literal]
+  include_examples 'parse', /a\{c/,          1 => [:escape, :interval_open,     EscapeSequence::Literal]
+  include_examples 'parse', /a\}c/,          1 => [:escape, :interval_close,    EscapeSequence::Literal]
+
+  # unicode escapes
+  include_examples 'parse', /a\u0640/,       1 => [:escape, :codepoint,         EscapeSequence::Codepoint]
+  include_examples 'parse', /a\u{41 1F60D}/, 1 => [:escape, :codepoint_list,    EscapeSequence::CodepointList]
+  include_examples 'parse', /a\u{10FFFF}/,   1 => [:escape, :codepoint_list,    EscapeSequence::CodepointList]
+
+    # hex escapes
+  include_examples 'parse', /a\xFF/n,        1 => [:escape, :hex,               EscapeSequence::Hex]
+
+  # octal escapes
+  include_examples 'parse', /a\177/n,        1 => [:escape, :octal,             EscapeSequence::Octal]
 
   specify('parse chars and codepoints') do
     root = RP.parse(/\n\?\101\x42\u0043\u{44 45}/)
@@ -65,6 +51,9 @@ RSpec.describe('Escape parsing') do
 
     expect(root[5].chars).to eq %w[D E]
     expect(root[5].codepoints).to eq [68, 69]
+
+    expect { root[5].char }.to raise_error(/#chars/)
+    expect { root[5].codepoint }.to raise_error(/#codepoints/)
   end
 
   specify('parse escape control sequence lower') do

data/spec/parser/groups_spec.rb

@@ -1,267 +1,108 @@
 require 'spec_helper'
 
 RSpec.describe('Group parsing') do
-  specify('parse root options mi') do
-    t = RP.parse(/[abc]/mi, 'ruby/1.8')
-
-    expect(t.m?).to be true
-    expect(t.i?).to be true
-    expect(t.x?).to be false
-  end
-
-  specify('parse option group') do
-    t = RP.parse(/(?m:a)/, 'ruby/1.8')
-
-    expect(t[0]).to be_instance_of(Group::Options)
-    expect(t[0].token).to eq :options
-
-    expect(t[0].m?).to be true
-    expect(t[0].i?).to be false
-    expect(t[0].x?).to be false
-
-    expect(t[0].option_changes[:m]).to be true
-    expect(t[0].option_changes[:i]).to be_nil
-  end
-
-  specify('parse self defeating option group') do
-    t = RP.parse(/(?m-m:a)/, 'ruby/1.8')
-
-    expect(t[0].m?).to be false
-    expect(t[0].i?).to be false
-    expect(t[0].x?).to be false
-
-    expect(t[0].option_changes[:m]).to be false
-    expect(t[0].option_changes[:i]).to be_nil
-  end
-
-  specify('parse nested options activate one') do
-    t = RP.parse(/(?x-mi:a(?m:b))/, 'ruby/1.8')
-
-    expect(t[0].m?).to be false
-    expect(t[0].i?).to be false
-    expect(t[0].x?).to be true
-
-    expect(t[0][1].m?).to be true
-    expect(t[0][1].i?).to be false
-    expect(t[0][1].x?).to be true
-
-    expect(t[0][1].option_changes[:m]).to be true
-    expect(t[0][1].option_changes[:i]).to be_nil
-    expect(t[0][1].option_changes[:x]).to be_nil
-  end
-
-  specify('parse nested options deactivate one') do
-    t = RP.parse(/(?ix-m:a(?-i:b))/, 'ruby/1.8')
-
-    expect(t[0].m?).to be false
-    expect(t[0].i?).to be true
-    expect(t[0].x?).to be true
-
-    expect(t[0][1].m?).to be false
-    expect(t[0][1].i?).to be false
-    expect(t[0][1].x?).to be true
-
-    expect(t[0][1].option_changes[:i]).to be false
-    expect(t[0][1].option_changes[:m]).to be_nil
-    expect(t[0][1].option_changes[:x]).to be_nil
-  end
-
-  specify('parse nested options invert all') do
-    t = RP.parse('(?xi-m:a(?m-ix:b))', 'ruby/1.8')
-
-    expect(t[0].m?).to be false
-    expect(t[0].i?).to be true
-    expect(t[0].x?).to be true
-
-    expect(t[0][1].m?).to be true
-    expect(t[0][1].i?).to be false
-    expect(t[0][1].x?).to be false
-
-    expect(t[0][1].option_changes[:m]).to be true
-    expect(t[0][1].option_changes[:i]).to be false
-    expect(t[0][1].option_changes[:x]).to be false
-  end
-
-  specify('parse nested options affect literal subexpressions') do
-    t = RP.parse(/(?x-mi:a(?m:b))/, 'ruby/1.8')
-
-    expect(t[0][0].m?).to be false
-    expect(t[0][0].i?).to be false
-    expect(t[0][0].x?).to be true
-
-    expect(t[0][1][0].m?).to be true
-    expect(t[0][1][0].i?).to be false
-    expect(t[0][1][0].x?).to be true
-  end
-
-  specify('parse option switch group') do
-    t = RP.parse(/a(?i-m)b/m, 'ruby/1.8')
-
-    expect(t[1]).to be_instance_of(Group::Options)
-    expect(t[1].token).to eq :options_switch
-
-    expect(t[1].m?).to be false
-    expect(t[1].i?).to be true
-    expect(t[1].x?).to be false
-
-    expect(t[1].option_changes[:i]).to be true
-    expect(t[1].option_changes[:m]).to be false
-    expect(t[1].option_changes[:x]).to be_nil
-  end
-
-  specify('parse option switch affects following expressions') do
-    t = RP.parse(/a(?i-m)b/m, 'ruby/1.8')
-
-    expect(t[0].m?).to be true
-    expect(t[0].i?).to be false
-    expect(t[0].x?).to be false
-
-    expect(t[2].m?).to be false
-    expect(t[2].i?).to be true
-    expect(t[2].x?).to be false
-  end
-
-  specify('parse option switch in group') do
-    t = RP.parse(/(a(?i-m)b)c/m, 'ruby/1.8')
-
-    group1 = t[0]
-
-    expect(group1.m?).to be true
-    expect(group1.i?).to be false
-    expect(group1.x?).to be false
-
-    expect(group1[0].m?).to be true
-    expect(group1[0].i?).to be false
-    expect(group1[0].x?).to be false
-
-    expect(group1[1].m?).to be false
-    expect(group1[1].i?).to be true
-    expect(group1[1].x?).to be false
-
-    expect(group1[2].m?).to be false
-    expect(group1[2].i?).to be true
-    expect(group1[2].x?).to be false
-
-    expect(t[1].m?).to be true
-    expect(t[1].i?).to be false
-    expect(t[1].x?).to be false
-  end
-
-  specify('parse nested option switch in group') do
-    t = RP.parse(/((?i-m)(a(?-i)b))/m, 'ruby/1.8')
-
-    group2 = t[0][1]
-
-    expect(group2.m?).to be false
-    expect(group2.i?).to be true
-    expect(group2.x?).to be false
-
-    expect(group2[0].m?).to be false
-    expect(group2[0].i?).to be true
-    expect(group2[0].x?).to be false
-
-    expect(group2[1].m?).to be false
-    expect(group2[1].i?).to be false
-    expect(group2[1].x?).to be false
-
-    expect(group2[2].m?).to be false
-    expect(group2[2].i?).to be false
-    expect(group2[2].x?).to be false
-  end
-
-  specify('parse options dau') do
-    t = RP.parse('(?dua:abc)')
-
-    expect(t[0].d?).to be false
-    expect(t[0].a?).to be true
-    expect(t[0].u?).to be false
-  end
-
-  specify('parse nested options dau') do
-    t = RP.parse('(?u:a(?d:b))')
-
-    expect(t[0].u?).to be true
-    expect(t[0].d?).to be false
-    expect(t[0].a?).to be false
-
-    expect(t[0][1].d?).to be true
-    expect(t[0][1].a?).to be false
-    expect(t[0][1].u?).to be false
-  end
-
-  specify('parse nested options da') do
-    t = RP.parse('(?di-xm:a(?da-x:b))')
-
-    expect(t[0].d?).to be true
-    expect(t[0].i?).to be true
-    expect(t[0].m?).to be false
-    expect(t[0].x?).to be false
-    expect(t[0].a?).to be false
-    expect(t[0].u?).to be false
-
-    expect(t[0][1].d?).to be false
-    expect(t[0][1].a?).to be true
-    expect(t[0][1].u?).to be false
-    expect(t[0][1].x?).to be false
-    expect(t[0][1].m?).to be false
-    expect(t[0][1].i?).to be true
-  end
-
-  specify('parse lookahead') do
-    t = RP.parse('(?=abc)(?!def)', 'ruby/1.8')
-
-    expect(t[0]).to be_a(Assertion::Lookahead)
-
-    expect(t[1]).to be_a(Assertion::NegativeLookahead)
-  end
-
-  specify('parse lookbehind') do
-    t = RP.parse('(?<=abc)(?<!def)', 'ruby/1.9')
-
-    expect(t[0]).to be_a(Assertion::Lookbehind)
-
-    expect(t[1]).to be_a(Assertion::NegativeLookbehind)
-  end
-
-  specify('parse comment') do
-    t = RP.parse('a(?# is for apple)b(?# for boy)c(?# cat)')
-
-    [1, 3, 5].each do |i|
-      expect(t[i]).to be_a(Group::Comment)
-
-      expect(t[i].type).to eq :group
-      expect(t[i].token).to eq :comment
-    end
-  end
-
-  specify('parse absence group', if: ruby_version_at_least('2.4.1')) do
-    t = RP.parse('a(?~b)c(?~d)e')
-
-    [1, 3].each do |i|
-      expect(t[i]).to be_a(Group::Absence)
-
-      expect(t[i].type).to eq :group
-      expect(t[i].token).to eq :absence
-    end
-  end
+  include_examples 'parse', /(?=abc)(?!def)/,
+    0 => [:assertion, :lookahead,   Assertion::Lookahead],
+    1 => [:assertion, :nlookahead,  Assertion::NegativeLookahead]
+
+  include_examples 'parse', /(?<=abc)(?<!def)/,
+    0 => [:assertion, :lookbehind,  Assertion::Lookbehind],
+    1 => [:assertion, :nlookbehind, Assertion::NegativeLookbehind]
+
+  include_examples 'parse', /a(?# is for apple)b(?# for boy)c(?# cat)/,
+    1 => [:group, :comment, Group::Comment],
+    3 => [:group, :comment, Group::Comment],
+    5 => [:group, :comment, Group::Comment]
+
+  if ruby_version_at_least('2.4.1')
+    include_examples 'parse', 'a(?~b)c(?~d)e',
+      1 => [:group, :absence, Group::Absence],
+      3 => [:group, :absence, Group::Absence]
+  end
+
+  include_examples 'parse', /(?m:a)/,
+    0 => [:group, :options, Group::Options, options: { m: true }, option_changes: { m: true }]
+
+  # self-defeating group option
+  include_examples 'parse', /(?m-m:a)/,
+    0 => [:group, :options, Group::Options, options: {}, option_changes: { m: false }]
+
+  # activate one option in nested group
+  include_examples 'parse', /(?x-mi:a(?m:b))/,
+    0      => [:group, :options, Group::Options, options: { x: true }, option_changes: { i: false, m: false, x: true }],
+    [0, 1] => [:group, :options, Group::Options, options: { m: true, x: true }, option_changes: { m: true }]
+
+  # deactivate one option in nested group
+  include_examples 'parse', /(?ix-m:a(?-i:b))/,
+    0      => [:group, :options, Group::Options, options: { i: true, x: true }, option_changes: { i: true, m: false, x: true }],
+    [0, 1] => [:group, :options, Group::Options, options: { x: true }, option_changes: { i: false }]
+
+  # invert all options in nested group
+  include_examples 'parse', /(?xi-m:a(?m-ix:b))/,
+    0      => [:group, :options, Group::Options, options: { i: true, x: true }, option_changes: { i: true, m: false, x: true }],
+    [0, 1] => [:group, :options, Group::Options, options: { m: true }, option_changes: { i: false, m: true, x: false }]
+
+  # nested options affect literal subexpressions
+  include_examples 'parse', /(?x-mi:a(?m:b))/,
+    [0, 0]    => [:literal, :literal, Literal, text: 'a', options: { x: true }],
+    [0, 1, 0] => [:literal, :literal, Literal, text: 'b', options: { m: true, x: true }]
+
+  # option switching group
+  include_examples 'parse', /a(?i-m)b/m,
+    0 => [:literal, :literal,         Literal,        text: 'a', options: { m: true }],
+    1 => [:group,   :options_switch,  Group::Options, options: { i: true }, option_changes: { i: true, m: false }],
+    2 => [:literal, :literal,         Literal,        text: 'b', options: { i: true }]
+
+  # option switch in group
+  include_examples 'parse', /(a(?i-m)b)c/m,
+    0      => [:group,   :capture,        Group::Capture, options: { m: true }],
+    [0, 0] => [:literal, :literal,        Literal,        text: 'a', options: { m: true }],
+    [0, 1] => [:group,   :options_switch, Group::Options, options: { i: true }, option_changes: { i: true, m: false }],
+    [0, 2] => [:literal, :literal,        Literal,        text: 'b', options: { i: true }],
+    1      => [:literal, :literal,        Literal,        text: 'c', options: { m: true }]
+
+  # nested option switch in group
+  include_examples 'parse', /((?i-m)(a(?-i)b))/m,
+    [0, 1]    => [:group,   :capture,        Group::Capture, options: { i: true }],
+    [0, 1, 0] => [:literal, :literal,        Literal,        text: 'a', options: { i: true }],
+    [0, 1, 1] => [:group,   :options_switch, Group::Options, options: {}, option_changes: { i: false }],
+    [0, 1, 2] => [:literal, :literal,        Literal,        text: 'b', options: {}]
+
+  # options dau
+  include_examples 'parse', /(?dua:abc)/,
+    0 => [:group, :options, Group::Options, options: { a: true }, option_changes: { a: true }]
+
+  # nested options dau
+  include_examples 'parse', /(?u:a(?d:b))/,
+    0         => [:group,   :options, Group::Options, options: { u: true }, option_changes: { u: true }],
+    [0, 1]    => [:group,   :options, Group::Options, options: { d: true }, option_changes: { d: true, u: false }],
+    [0, 1, 0] => [:literal, :literal, Literal,        text: 'b', options: { d: true }]
+
+  # nested options da
+  include_examples 'parse', /(?di-xm:a(?da-x:b))/,
+    0         => [:group,   :options, Group::Options, options: { d: true, i:true }],
+    [0, 1]    => [:group,   :options, Group::Options, options: { a: true, i: true }, option_changes: { a: true, d: false, x: false}],
+    [0, 1, 0] => [:literal, :literal, Literal,        text: 'b', options: { a: true, i: true }]
 
   specify('parse group number') do
-    t = RP.parse('(a)(?=b)((?:c)(d|(e)))')
-    expect(t[0].number).to eq 1
-    expect(t[1]).not_to respond_to(:number)
-    expect(t[2].number).to eq 2
-    expect(t[2][0]).not_to respond_to(:number)
-    expect(t[2][1].number).to eq 3
-    expect(t[2][1][0][1][0].number).to eq 4
+    root = RP.parse(/(a)(?=b)((?:c)(d|(e)))/)
+
+    expect(root[0].number).to eq 1
+    expect(root[1]).not_to respond_to(:number)
+    expect(root[2].number).to eq 2
+    expect(root[2][0]).not_to respond_to(:number)
+    expect(root[2][1].number).to eq 3
+    expect(root[2][1][0][1][0].number).to eq 4
   end
 
   specify('parse group number at level') do
-    t = RP.parse('(a)(?=b)((?:c)(d|(e)))')
-    expect(t[0].number_at_level).to eq 1
-    expect(t[1]).not_to respond_to(:number_at_level)
-    expect(t[2].number_at_level).to eq 2
-    expect(t[2][0]).not_to respond_to(:number_at_level)
-    expect(t[2][1].number_at_level).to eq 1
-    expect(t[2][1][0][1][0].number_at_level).to eq 1
+    root = RP.parse(/(a)(?=b)((?:c)(d|(e)))/)
+
+    expect(root[0].number_at_level).to eq 1
+    expect(root[1]).not_to respond_to(:number_at_level)
+    expect(root[2].number_at_level).to eq 2
+    expect(root[2][0]).not_to respond_to(:number_at_level)
+    expect(root[2][1].number_at_level).to eq 1
+    expect(root[2][1][0][1][0].number_at_level).to eq 1
   end
 end