regexp_parser 1.3.0 → 1.6.0

data/spec/parser/groups_spec.rb

@@ -0,0 +1,108 @@
+require 'spec_helper'
+
+RSpec.describe('Group parsing') do
+  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
+    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
+    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

data/spec/parser/keep_spec.rb

@@ -0,0 +1,6 @@
+require 'spec_helper'
+
+RSpec.describe('Keep parsing') do
+  include_examples 'parse', /ab\Kcd/, 1      => [:keep, :mark, Keep::Mark, text: '\K']
+  include_examples 'parse', /(a\K)/,  [0, 1] => [:keep, :mark, Keep::Mark, text: '\K']
+end

data/spec/parser/posix_classes_spec.rb

@@ -0,0 +1,8 @@
+require 'spec_helper'
+
+RSpec.describe('PosixClass parsing') do
+  include_examples 'parse', /[[:word:]]/,  [0, 0] => [:posixclass,    :word, PosixClass,
+                                           name: 'word', text: '[:word:]', negative?: false]
+  include_examples 'parse', /[[:^word:]]/, [0, 0] => [:nonposixclass, :word, PosixClass,
+                                           name: 'word', text: '[:^word:]', negative?: true]
+end

data/spec/parser/properties_spec.rb

@@ -0,0 +1,115 @@
+require 'spec_helper'
+
+RSpec.describe('Property parsing') do
+  example_props = [
+    'Alnum',
+    'Any',
+    'Age=1.1',
+    'Dash',
+    'di',
+    'Default_Ignorable_Code_Point',
+    'Math',
+    'Noncharacter-Code_Point', # test dash
+    'sd',
+    'Soft Dotted', # test whitespace
+    'sterm',
+    'xidc',
+    'XID_Continue',
+    'Emoji',
+    'InChessSymbols'
+  ]
+
+  example_props.each do |name|
+    it("parses property #{name}") do
+      exp = RP.parse("ab\\p{#{name}}", '*').last
+
+      expect(exp).to be_a(UnicodeProperty::Base)
+      expect(exp.type).to eq :property
+      expect(exp.name).to eq name
+    end
+
+    it("parses nonproperty #{name}") do
+      exp = RP.parse("ab\\P{#{name}}", '*').last
+
+      expect(exp).to be_a(UnicodeProperty::Base)
+      expect(exp.type).to eq :nonproperty
+      expect(exp.name).to eq name
+    end
+  end
+
+  specify('parse all properties of current ruby') do
+    unsupported = RegexpPropertyValues.all_for_current_ruby.reject do |prop|
+      RP.parse("\\p{#{prop}}") rescue false
+    end
+    expect(unsupported).to be_empty
+  end
+
+  specify('parse property negative') do
+    root = RP.parse('ab\p{L}cd', 'ruby/1.9')
+    expect(root[1]).not_to be_negative
+  end
+
+  specify('parse nonproperty negative') do
+    root = RP.parse('ab\P{L}cd', 'ruby/1.9')
+    expect(root[1]).to be_negative
+  end
+
+  specify('parse caret nonproperty negative') do
+    root = RP.parse('ab\p{^L}cd', 'ruby/1.9')
+    expect(root[1]).to be_negative
+  end
+
+  specify('parse double negated property negative') do
+    root = RP.parse('ab\P{^L}cd', 'ruby/1.9')
+    expect(root[1]).not_to be_negative
+  end
+
+  specify('parse property shortcut') do
+    expect(RP.parse('\p{lowercase_letter}')[0].shortcut).to eq 'll'
+    expect(RP.parse('\p{sc}')[0].shortcut).to eq 'sc'
+    expect(RP.parse('\p{in_bengali}')[0].shortcut).to be_nil
+  end
+
+  specify('parse property age') do
+    root = RP.parse('ab\p{age=5.2}cd', 'ruby/1.9')
+    expect(root[1]).to be_a(UnicodeProperty::Age)
+  end
+
+  specify('parse property derived') do
+    root = RP.parse('ab\p{Math}cd', 'ruby/1.9')
+    expect(root[1]).to be_a(UnicodeProperty::Derived)
+  end
+
+  specify('parse property script') do
+    root = RP.parse('ab\p{Hiragana}cd', 'ruby/1.9')
+    expect(root[1]).to be_a(UnicodeProperty::Script)
+  end
+
+  specify('parse property script V1 9 3') do
+    root = RP.parse('ab\p{Brahmi}cd', 'ruby/1.9.3')
+    expect(root[1]).to be_a(UnicodeProperty::Script)
+  end
+
+  specify('parse property script V2 2 0') do
+    root = RP.parse('ab\p{Caucasian_Albanian}cd', 'ruby/2.2')
+    expect(root[1]).to be_a(UnicodeProperty::Script)
+  end
+
+  specify('parse property block') do
+    root = RP.parse('ab\p{InArmenian}cd', 'ruby/1.9')
+    expect(root[1]).to be_a(UnicodeProperty::Block)
+  end
+
+  specify('parse property following literal') do
+    root = RP.parse('ab\p{Lu}cd', 'ruby/1.9')
+    expect(root[2]).to be_a(Literal)
+  end
+
+  specify('parse abandoned newline property') do
+    root = RP.parse('\p{newline}', 'ruby/1.9')
+    expect(root.expressions.last).to be_a(UnicodeProperty::Base)
+
+    expect { RP.parse('\p{newline}', 'ruby/2.0') }
+      .to raise_error(Regexp::Syntax::NotImplementedError)
+  end
+end

data/spec/parser/quantifiers_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+
+RSpec.describe('Quantifier parsing') do
+  RSpec.shared_examples 'quantifier' do |pattern, text, mode, token, min, max|
+    it "parses the quantifier in #{pattern} as #{mode} #{token}" do
+      root = RP.parse(pattern, '*')
+      exp = root[0]
+
+      expect(exp).to be_quantified
+      expect(exp.quantifier.token).to eq token
+      expect(exp.quantifier.min).to eq min
+      expect(exp.quantifier.max).to eq max
+      expect(exp.quantifier.mode).to eq mode
+    end
+  end
+
+  include_examples 'quantifier', /a?b/,      '?',      :greedy,     :zero_or_one,  0, 1
+  include_examples 'quantifier', /a??b/,     '??',     :reluctant,  :zero_or_one,  0, 1
+  include_examples 'quantifier', /a?+b/,     '?+',     :possessive, :zero_or_one,  0, 1
+  include_examples 'quantifier', /a*b/,      '*',      :greedy,     :zero_or_more, 0, -1
+  include_examples 'quantifier', /a*?b/,     '*?',     :reluctant,  :zero_or_more, 0, -1
+  include_examples 'quantifier', /a*+b/,     '*+',     :possessive, :zero_or_more, 0, -1
+  include_examples 'quantifier', /a+b/,      '+',      :greedy,     :one_or_more,  1, -1
+  include_examples 'quantifier', /a+?b/,     '+?',     :reluctant,  :one_or_more,  1, -1
+  include_examples 'quantifier', /a++b/,     '++',     :possessive, :one_or_more,  1, -1
+  include_examples 'quantifier', /a{2,4}b/,  '{2,4}',  :greedy,     :interval,     2, 4
+  include_examples 'quantifier', /a{2,4}?b/, '{2,4}?', :reluctant,  :interval,     2, 4
+  include_examples 'quantifier', /a{2,4}+b/, '{2,4}+', :possessive, :interval,     2, 4
+  include_examples 'quantifier', /a{2,}b/,   '{2,}',   :greedy,     :interval,     2, -1
+  include_examples 'quantifier', /a{2,}?b/,  '{2,}?',  :reluctant,  :interval,     2, -1
+  include_examples 'quantifier', /a{2,}+b/,  '{2,}+',  :possessive, :interval,     2, -1
+  include_examples 'quantifier', /a{,3}b/,   '{,3}',   :greedy,     :interval,     0, 3
+  include_examples 'quantifier', /a{,3}?b/,  '{,3}?',  :reluctant,  :interval,     0, 3
+  include_examples 'quantifier', /a{,3}+b/,  '{,3}+',  :possessive, :interval,     0, 3
+  include_examples 'quantifier', /a{4}b/,    '{4}',    :greedy,     :interval,     4, 4
+  include_examples 'quantifier', /a{4}?b/,   '{4}?',   :reluctant,  :interval,     4, 4
+  include_examples 'quantifier', /a{4}+b/,   '{4}+',   :possessive, :interval,     4, 4
+
+  specify('mode-checking methods') do
+    exp = RP.parse(/a??/).first
+
+    expect(exp).to be_reluctant
+    expect(exp).to be_lazy
+    expect(exp).not_to be_greedy
+    expect(exp).not_to be_possessive
+    expect(exp.quantifier).to be_reluctant
+    expect(exp.quantifier).to be_lazy
+    expect(exp.quantifier).not_to be_greedy
+    expect(exp.quantifier).not_to be_possessive
+  end
+end

data/spec/parser/refcalls_spec.rb

@@ -0,0 +1,112 @@
+require 'spec_helper'
+
+RSpec.describe('Refcall parsing') do
+  include_examples 'parse', /(abc)\1/,
+    1 => [:backref, :number, Backreference::Number, number: 1]
+
+  include_examples 'parse', /(?<X>abc)\k<X>/,
+    1 => [:backref, :name_ref, Backreference::Name, name: 'X']
+  include_examples 'parse', /(?<X>abc)\k'X'/,
+    1 => [:backref, :name_ref, Backreference::Name, name: 'X']
+
+  include_examples 'parse', /(abc)\k<1>/,
+    1 => [:backref, :number_ref, Backreference::Number, number: 1]
+  include_examples 'parse', /(abc)\k'1'/,
+    1 => [:backref, :number_ref, Backreference::Number, number: 1]
+
+  include_examples 'parse', /(abc)\k<-1>/,
+    1 => [:backref, :number_rel_ref, Backreference::NumberRelative, number: -1]
+  include_examples 'parse', /(abc)\k'-1'/,
+    1 => [:backref, :number_rel_ref, Backreference::NumberRelative, number: -1]
+
+  include_examples 'parse', /(?<X>abc)\g<X>/,
+    1 => [:backref, :name_call, Backreference::NameCall, name: 'X']
+  include_examples 'parse', /(?<X>abc)\g'X'/,
+    1 => [:backref, :name_call, Backreference::NameCall, name: 'X']
+
+  include_examples 'parse', /(abc)\g<1>/,
+    1 => [:backref, :number_call, Backreference::NumberCall, number: 1]
+  include_examples 'parse', /(abc)\g'1'/,
+    1 => [:backref, :number_call, Backreference::NumberCall, number: 1]
+
+  include_examples 'parse', /(abc)\g<-1>/,
+    1 => [:backref, :number_rel_call, Backreference::NumberCallRelative, number: -1]
+  include_examples 'parse', /(abc)\g'-1'/,
+    1 => [:backref, :number_rel_call, Backreference::NumberCallRelative, number: -1]
+
+  include_examples 'parse', /\g<+1>(abc)/,
+    0 => [:backref, :number_rel_call, Backreference::NumberCallRelative, number: 1]
+  include_examples 'parse', /\g'+1'(abc)/,
+    0 => [:backref, :number_rel_call, Backreference::NumberCallRelative, number: 1]
+
+  include_examples 'parse', /(?<X>abc)\k<X-0>/,
+    1 => [:backref, :name_recursion_ref,   Backreference::NameRecursionLevel,
+          name: 'X', recursion_level: 0]
+  include_examples 'parse', /(?<X>abc)\k'X-0'/,
+    1 => [:backref, :name_recursion_ref,   Backreference::NameRecursionLevel,
+          name: 'X', recursion_level: 0]
+
+  include_examples 'parse', /(abc)\k<1-0>/,
+    1 => [:backref, :number_recursion_ref, Backreference::NumberRecursionLevel,
+          number: 1, recursion_level: 0]
+  include_examples 'parse', /(abc)\k'1-0'/,
+    1 => [:backref, :number_recursion_ref, Backreference::NumberRecursionLevel,
+          number: 1, recursion_level: 0]
+  include_examples 'parse', /(abc)\k'-1+0'/,
+    1 => [:backref, :number_recursion_ref, Backreference::NumberRecursionLevel,
+          number: -1, recursion_level: 0]
+  include_examples 'parse', /(abc)\k'1+1'/,
+    1 => [:backref, :number_recursion_ref, Backreference::NumberRecursionLevel,
+          number: 1, recursion_level: 1]
+  include_examples 'parse', /(abc)\k'1-1'/,
+    1 => [:backref, :number_recursion_ref, Backreference::NumberRecursionLevel,
+          number: 1, recursion_level: -1]
+
+  specify('parse backref effective_number') do
+    root = RP.parse('(abc)(def)\\k<-1>(ghi)\\k<-3>\\k<-1>', 'ruby/1.9')
+    exp1 = root[2]
+    exp2 = root[4]
+    exp3 = root[5]
+
+    expect([exp1, exp2, exp3]).to all be_instance_of(Backreference::NumberRelative)
+    expect(exp1.effective_number).to eq 2
+    expect(exp2.effective_number).to eq 1
+    expect(exp3.effective_number).to eq 3
+  end
+
+  specify('parse backref referenced_expression') do
+    root = RP.parse('(abc)(def)\\k<-1>(ghi)\\k<-3>\\k<-1>', 'ruby/1.9')
+    exp1 = root[2]
+    exp2 = root[4]
+    exp3 = root[5]
+
+    expect([exp1, exp2, exp3]).to all be_instance_of(Backreference::NumberRelative)
+    expect(exp1.referenced_expression.to_s).to eq '(def)'
+    expect(exp2.referenced_expression.to_s).to eq '(abc)'
+    expect(exp3.referenced_expression.to_s).to eq '(ghi)'
+  end
+
+  specify('parse backref call effective_number') do
+    root = RP.parse('\\g<+1>(abc)\\g<+2>(def)(ghi)\\g<-2>', 'ruby/1.9')
+    exp1 = root[0]
+    exp2 = root[2]
+    exp3 = root[5]
+
+    expect([exp1, exp2, exp3]).to all be_instance_of(Backreference::NumberCallRelative)
+    expect(exp1.effective_number).to eq 1
+    expect(exp2.effective_number).to eq 3
+    expect(exp3.effective_number).to eq 2
+  end
+
+  specify('parse backref call referenced_expression') do
+    root = RP.parse('\\g<+1>(abc)\\g<+2>(def)(ghi)\\g<-2>', 'ruby/1.9')
+    exp1 = root[0]
+    exp2 = root[2]
+    exp3 = root[5]
+
+    expect([exp1, exp2, exp3]).to all be_instance_of(Backreference::NumberCallRelative)
+    expect(exp1.referenced_expression.to_s).to eq '(abc)'
+    expect(exp2.referenced_expression.to_s).to eq '(ghi)'
+    expect(exp3.referenced_expression.to_s).to eq '(def)'
+  end
+end

data/spec/parser/set/intersections_spec.rb

@@ -0,0 +1,127 @@
+require 'spec_helper'
+
+# edge cases with `...-&&...` and `...&&-...` are checked in test_ranges.rb
+
+RSpec.describe('CharacterSet::Intersection parsing') do
+  specify('parse set intersection') do
+    root = RP.parse('[a&&z]')
+    set = root[0]
+    ints = set[0]
+
+    expect(set.count).to eq 1
+    expect(ints).to be_instance_of(CharacterSet::Intersection)
+    expect(ints.count).to eq 2
+
+    seq1, seq2 = ints.expressions
+    expect(seq1).to be_instance_of(CharacterSet::IntersectedSequence)
+    expect(seq1.count).to eq 1
+    expect(seq1.first.to_s).to eq 'a'
+    expect(seq1.first).to be_instance_of(Literal)
+    expect(seq2).to be_instance_of(CharacterSet::IntersectedSequence)
+    expect(seq2.count).to eq 1
+    expect(seq2.first.to_s).to eq 'z'
+    expect(seq2.first).to be_instance_of(Literal)
+
+    expect(set).not_to match 'a'
+    expect(set).not_to match '&'
+    expect(set).not_to match 'z'
+  end
+
+  specify('parse set intersection range and subset') do
+    root = RP.parse('[a-z&&[^a]]')
+    set = root[0]
+    ints = set[0]
+
+    expect(set.count).to eq 1
+    expect(ints).to be_instance_of(CharacterSet::Intersection)
+    expect(ints.count).to eq 2
+
+    seq1, seq2 = ints.expressions
+    expect(seq1).to be_instance_of(CharacterSet::IntersectedSequence)
+    expect(seq1.count).to eq 1
+    expect(seq1.first.to_s).to eq 'a-z'
+    expect(seq1.first).to be_instance_of(CharacterSet::Range)
+    expect(seq2).to be_instance_of(CharacterSet::IntersectedSequence)
+    expect(seq2.count).to eq 1
+    expect(seq2.first.to_s).to eq '[^a]'
+    expect(seq2.first).to be_instance_of(CharacterSet)
+
+    expect(set).not_to match 'a'
+    expect(set).not_to match '&'
+    expect(set).to     match 'b'
+  end
+
+  specify('parse set intersection trailing range') do
+    root = RP.parse('[a&&a-z]')
+    set = root[0]
+    ints = set[0]
+
+    expect(set.count).to eq 1
+    expect(ints).to be_instance_of(CharacterSet::Intersection)
+    expect(ints.count).to eq 2
+
+    seq1, seq2 = ints.expressions
+    expect(seq1).to be_instance_of(CharacterSet::IntersectedSequence)
+    expect(seq1.count).to eq 1
+    expect(seq1.first.to_s).to eq 'a'
+    expect(seq1.first).to be_instance_of(Literal)
+    expect(seq2).to be_instance_of(CharacterSet::IntersectedSequence)
+    expect(seq2.count).to eq 1
+    expect(seq2.first.to_s).to eq 'a-z'
+    expect(seq2.first).to be_instance_of(CharacterSet::Range)
+
+    expect(set).to     match 'a'
+    expect(set).not_to match '&'
+    expect(set).not_to match 'b'
+  end
+
+  specify('parse set intersection type') do
+    root = RP.parse('[a&&\\w]')
+    set = root[0]
+    ints = set[0]
+
+    expect(set.count).to eq 1
+    expect(ints).to be_instance_of(CharacterSet::Intersection)
+    expect(ints.count).to eq 2
+
+    seq1, seq2 = ints.expressions
+    expect(seq1).to be_instance_of(CharacterSet::IntersectedSequence)
+    expect(seq1.count).to eq 1
+    expect(seq1.first.to_s).to eq 'a'
+    expect(seq1.first).to be_instance_of(Literal)
+    expect(seq2).to be_instance_of(CharacterSet::IntersectedSequence)
+    expect(seq2.count).to eq 1
+    expect(seq2.first.to_s).to eq '\\w'
+    expect(seq2.first).to be_instance_of(CharacterType::Word)
+
+    expect(set).to     match 'a'
+    expect(set).not_to match '&'
+    expect(set).not_to match 'b'
+  end
+
+  specify('parse set intersection multipart') do
+    root = RP.parse('[\\h&&\\w&&efg]')
+    set = root[0]
+    ints = set[0]
+
+    expect(set.count).to eq 1
+    expect(ints).to be_instance_of(CharacterSet::Intersection)
+    expect(ints.count).to eq 3
+
+    seq1, seq2, seq3 = ints.expressions
+    expect(seq1).to be_instance_of(CharacterSet::IntersectedSequence)
+    expect(seq1.count).to eq 1
+    expect(seq1.first.to_s).to eq '\\h'
+    expect(seq2).to be_instance_of(CharacterSet::IntersectedSequence)
+    expect(seq2.count).to eq 1
+    expect(seq2.first.to_s).to eq '\\w'
+    expect(seq3).to be_instance_of(CharacterSet::IntersectedSequence)
+    expect(seq3.count).to eq 3
+    expect(seq3.to_s).to eq 'efg'
+
+    expect(set).to     match 'e'
+    expect(set).to     match 'f'
+    expect(set).not_to match 'a'
+    expect(set).not_to match 'g'
+  end
+end