regexp_parser 1.7.0 → 2.8.1

data/spec/parser/properties_spec.rb

@@ -1,115 +0,0 @@
-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

@@ -1,51 +0,0 @@
-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

@@ -1,112 +0,0 @@
-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

@@ -1,127 +0,0 @@
-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

data/spec/parser/set/ranges_spec.rb

@@ -1,111 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe('CharacterSet::Range parsing') do
-  specify('parse set range') do
-    root = RP.parse('[a-z]')
-    set = root[0]
-    range = set[0]
-
-    expect(set.count).to eq 1
-    expect(range).to be_instance_of(CharacterSet::Range)
-    expect(range.count).to eq 2
-    expect(range.first.to_s).to eq 'a'
-    expect(range.first).to be_instance_of(Literal)
-    expect(range.last.to_s).to eq 'z'
-    expect(range.last).to be_instance_of(Literal)
-    expect(set).to match 'm'
-  end
-
-  specify('parse set range hex') do
-    root = RP.parse('[\\x00-\\x99]')
-    set = root[0]
-    range = set[0]
-
-    expect(set.count).to eq 1
-    expect(range).to be_instance_of(CharacterSet::Range)
-    expect(range.count).to eq 2
-    expect(range.first.to_s).to eq '\\x00'
-    expect(range.first).to be_instance_of(EscapeSequence::Hex)
-    expect(range.last.to_s).to eq '\\x99'
-    expect(range.last).to be_instance_of(EscapeSequence::Hex)
-    expect(set).to match '\\x50'
-  end
-
-  specify('parse set range unicode') do
-    root = RP.parse('[\\u{40 42}-\\u1234]')
-    set = root[0]
-    range = set[0]
-
-    expect(set.count).to eq 1
-    expect(range).to be_instance_of(CharacterSet::Range)
-    expect(range.count).to eq 2
-    expect(range.first.to_s).to eq '\\u{40 42}'
-    expect(range.first).to be_instance_of(EscapeSequence::CodepointList)
-    expect(range.last.to_s).to eq '\\u1234'
-    expect(range.last).to be_instance_of(EscapeSequence::Codepoint)
-    expect(set).to match '\\u600'
-  end
-
-  specify('parse set range edge case leading dash') do
-    root = RP.parse('[--z]')
-    set = root[0]
-    range = set[0]
-
-    expect(set.count).to eq 1
-    expect(range.count).to eq 2
-    expect(set).to match 'a'
-  end
-
-  specify('parse set range edge case trailing dash') do
-    root = RP.parse('[!--]')
-    set = root[0]
-    range = set[0]
-
-    expect(set.count).to eq 1
-    expect(range.count).to eq 2
-    expect(set).to match '$'
-  end
-
-  specify('parse set range edge case leading negate') do
-    root = RP.parse('[^-z]')
-    set = root[0]
-
-    expect(set.count).to eq 2
-    expect(set).to     match 'a'
-    expect(set).not_to match 'z'
-  end
-
-  specify('parse set range edge case trailing negate') do
-    root = RP.parse('[!-^]')
-    set = root[0]
-    range = set[0]
-
-    expect(set.count).to eq 1
-    expect(range.count).to eq 2
-    expect(set).to match '$'
-  end
-
-  specify('parse set range edge case leading intersection') do
-    root = RP.parse('[[\\-ab]&&-bc]')
-    set = root[0]
-
-    expect(set.count).to eq 1
-    expect(set.first.last.to_s).to eq '-bc'
-    expect(set).to     match '-'
-    expect(set).to     match 'b'
-    expect(set).not_to match 'a'
-    expect(set).not_to match 'c'
-  end
-
-  specify('parse set range edge case trailing intersection') do
-    root = RP.parse('[bc-&&[\\-ab]]')
-    set = root[0]
-
-    expect(set.count).to eq 1
-    expect(set.first.first.to_s).to eq 'bc-'
-    expect(set).to     match '-'
-    expect(set).to     match 'b'
-    expect(set).not_to match 'a'
-    expect(set).not_to match 'c'
-  end
-end

data/spec/parser/sets_spec.rb

@@ -1,178 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe('CharacterSet parsing') do
-  specify('parse set basic') do
-    root = RP.parse('[ab]+')
-    exp = root[0]
-
-    expect(exp).to be_instance_of(CharacterSet)
-    expect(exp.count).to eq 2
-
-    expect(exp[0]).to be_instance_of(Literal)
-    expect(exp[0].text).to eq 'a'
-    expect(exp[1]).to be_instance_of(Literal)
-    expect(exp[1].text).to eq 'b'
-
-    expect(exp).to be_quantified
-    expect(exp.quantifier.min).to eq 1
-    expect(exp.quantifier.max).to eq(-1)
-  end
-
-  specify('parse set char type') do
-    root = RP.parse('[a\\dc]')
-    exp = root[0]
-
-    expect(exp).to be_instance_of(CharacterSet)
-    expect(exp.count).to eq 3
-
-    expect(exp[1]).to be_instance_of(CharacterType::Digit)
-    expect(exp[1].text).to eq '\\d'
-  end
-
-  specify('parse set escape sequence backspace') do
-    root = RP.parse('[a\\bc]')
-    exp = root[0]
-
-    expect(exp).to be_instance_of(CharacterSet)
-    expect(exp.count).to eq 3
-
-    expect(exp[1]).to be_instance_of(EscapeSequence::Backspace)
-    expect(exp[1].text).to eq '\\b'
-
-    expect(exp).to     match 'a'
-    expect(exp).to     match "\b"
-    expect(exp).not_to match 'b'
-    expect(exp).to     match 'c'
-  end
-
-  specify('parse set escape sequence hex') do
-    root = RP.parse('[a\\x20c]', :any)
-    exp = root[0]
-
-    expect(exp).to be_instance_of(CharacterSet)
-    expect(exp.count).to eq 3
-
-    expect(exp[1]).to be_instance_of(EscapeSequence::Hex)
-    expect(exp[1].text).to eq '\\x20'
-  end
-
-  specify('parse set escape sequence codepoint') do
-    root = RP.parse('[a\\u0640]')
-    exp = root[0]
-
-    expect(exp).to be_instance_of(CharacterSet)
-    expect(exp.count).to eq 2
-
-    expect(exp[1]).to be_instance_of(EscapeSequence::Codepoint)
-    expect(exp[1].text).to eq '\\u0640'
-  end
-
-  specify('parse set escape sequence codepoint list') do
-    root = RP.parse('[a\\u{41 1F60D}]')
-    exp = root[0]
-
-    expect(exp).to be_instance_of(CharacterSet)
-    expect(exp.count).to eq 2
-
-    expect(exp[1]).to be_instance_of(EscapeSequence::CodepointList)
-    expect(exp[1].text).to eq '\\u{41 1F60D}'
-  end
-
-  specify('parse set posix class') do
-    root = RP.parse('[[:digit:][:^lower:]]+')
-    exp = root[0]
-
-    expect(exp).to be_instance_of(CharacterSet)
-    expect(exp.count).to eq 2
-
-    expect(exp[0]).to be_instance_of(PosixClass)
-    expect(exp[0].text).to eq '[:digit:]'
-    expect(exp[1]).to be_instance_of(PosixClass)
-    expect(exp[1].text).to eq '[:^lower:]'
-  end
-
-  specify('parse set nesting') do
-    root = RP.parse('[a[b[c]d]e]')
-
-    exp = root[0]
-    expect(exp).to be_instance_of(CharacterSet)
-    expect(exp.count).to eq 3
-    expect(exp[0]).to be_instance_of(Literal)
-    expect(exp[2]).to be_instance_of(Literal)
-
-    subset1 = exp[1]
-    expect(subset1).to be_instance_of(CharacterSet)
-    expect(subset1.count).to eq 3
-    expect(subset1[0]).to be_instance_of(Literal)
-    expect(subset1[2]).to be_instance_of(Literal)
-
-    subset2 = subset1[1]
-    expect(subset2).to be_instance_of(CharacterSet)
-    expect(subset2.count).to eq 1
-    expect(subset2[0]).to be_instance_of(Literal)
-  end
-
-  specify('parse set nesting negative') do
-    root = RP.parse('[a[^b[c]]]')
-    exp = root[0]
-
-    expect(exp).to be_instance_of(CharacterSet)
-    expect(exp.count).to eq 2
-    expect(exp[0]).to be_instance_of(Literal)
-    expect(exp).not_to be_negative
-
-    subset1 = exp[1]
-    expect(subset1).to be_instance_of(CharacterSet)
-    expect(subset1.count).to eq 2
-    expect(subset1[0]).to be_instance_of(Literal)
-    expect(subset1).to be_negative
-
-    subset2 = subset1[1]
-    expect(subset2).to be_instance_of(CharacterSet)
-    expect(subset2.count).to eq 1
-    expect(subset2[0]).to be_instance_of(Literal)
-    expect(subset2).not_to be_negative
-  end
-
-  specify('parse set nesting #to_s') do
-    pattern = '[a[b[^c]]]'
-    root = RP.parse(pattern)
-
-    expect(root.to_s).to eq pattern
-  end
-
-  specify('parse set literals are not merged') do
-    root = RP.parse("[#{('a' * 10)}]")
-    exp = root[0]
-
-    expect(exp.count).to eq 10
-  end
-
-  specify('parse set whitespace is not merged') do
-    root = RP.parse("[#{(' ' * 10)}]")
-    exp = root[0]
-
-    expect(exp.count).to eq 10
-  end
-
-  specify('parse set whitespace is not merged in x mode') do
-    root = RP.parse("(?x)[#{(' ' * 10)}]")
-    exp = root[1]
-
-    expect(exp.count).to eq 10
-  end
-
-  specify('parse set collating sequence') do
-    root = RP.parse('[a[.span-ll.]h]', :any)
-    exp = root[0]
-
-    expect(exp[1].to_s).to eq '[.span-ll.]'
-  end
-
-  specify('parse set character equivalents') do
-    root = RP.parse('[a[=e=]h]', :any)
-    exp = root[0]
-
-    expect(exp[1].to_s).to eq '[=e=]'
-  end
-end