regexp_parser 1.4.0 → 1.5.0

data/spec/parser/refcalls_spec.rb

@@ -0,0 +1,237 @@
+require 'spec_helper'
+
+RSpec.describe('Refcall parsing') do
+  specify('parse traditional number backref') do
+    root = RP.parse('(abc)\\1', 'ruby/1.9')
+    exp = root[1]
+
+    expect(exp).to be_instance_of(Backreference::Number)
+    expect(exp.number).to eq 1
+  end
+
+  specify('parse backref named ab') do
+    root = RP.parse('(?<X>abc)\\k<X>', 'ruby/1.9')
+    exp = root[1]
+
+    expect(exp).to be_instance_of(Backreference::Name)
+    expect(exp.name).to eq 'X'
+  end
+
+  specify('parse backref named sq') do
+    root = RP.parse("(?<X>abc)\\k'X'", 'ruby/1.9')
+    exp = root[1]
+
+    expect(exp).to be_instance_of(Backreference::Name)
+    expect(exp.name).to eq 'X'
+  end
+
+  specify('parse backref number ab') do
+    root = RP.parse('(abc)\\k<1>', 'ruby/1.9')
+    exp = root[1]
+
+    expect(exp).to be_instance_of(Backreference::Number)
+    expect(exp.number).to eq 1
+  end
+
+  specify('parse backref number sq') do
+    root = RP.parse("(abc)\\k'1'", 'ruby/1.9')
+    exp = root[1]
+
+    expect(exp).to be_instance_of(Backreference::Number)
+    expect(exp.number).to eq 1
+  end
+
+  specify('parse backref number relative ab') do
+    root = RP.parse('(abc)\\k<-1>', 'ruby/1.9')
+    exp = root[1]
+
+    expect(exp).to be_instance_of(Backreference::NumberRelative)
+    expect(exp.number).to eq(-1)
+  end
+
+  specify('parse backref number relative sq') do
+    root = RP.parse("(abc)\\k'-1'", 'ruby/1.9')
+    exp = root[1]
+
+    expect(exp).to be_instance_of(Backreference::NumberRelative)
+    expect(exp.number).to eq(-1)
+  end
+
+  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 name call ab') do
+    root = RP.parse('(?<X>abc)\\g<X>', 'ruby/1.9')
+    exp = root[1]
+
+    expect(exp).to be_instance_of(Backreference::NameCall)
+    expect(exp.name).to eq 'X'
+  end
+
+  specify('parse backref name call sq') do
+    root = RP.parse("(?<X>abc)\\g'X'", 'ruby/1.9')
+    exp = root[1]
+
+    expect(exp).to be_instance_of(Backreference::NameCall)
+    expect(exp.name).to eq 'X'
+  end
+
+  specify('parse backref number call ab') do
+    root = RP.parse('(abc)\\g<1>', 'ruby/1.9')
+    exp = root[1]
+
+    expect(exp).to be_instance_of(Backreference::NumberCall)
+    expect(exp.number).to eq 1
+  end
+
+  specify('parse backref number call sq') do
+    root = RP.parse("(abc)\\g'1'", 'ruby/1.9')
+    exp = root[1]
+
+    expect(exp).to be_instance_of(Backreference::NumberCall)
+    expect(exp.number).to eq 1
+  end
+
+  specify('parse backref number relative call ab') do
+    root = RP.parse('(abc)\\g<-1>', 'ruby/1.9')
+    exp = root[1]
+
+    expect(exp).to be_instance_of(Backreference::NumberCallRelative)
+    expect(exp.number).to eq(-1)
+  end
+
+  specify('parse backref number relative call sq') do
+    root = RP.parse("(abc)\\g'-1'", 'ruby/1.9')
+    exp = root[1]
+
+    expect(exp).to be_instance_of(Backreference::NumberCallRelative)
+    expect(exp.number).to eq(-1)
+  end
+
+  specify('parse backref number relative forward call ab') do
+    root = RP.parse('\\g<+1>(abc)', 'ruby/1.9')
+    exp = root[0]
+
+    expect(exp).to be_instance_of(Backreference::NumberCallRelative)
+    expect(exp.number).to eq 1
+  end
+
+  specify('parse backref number relative forward call sq') do
+    root = RP.parse("\\g'+1'(abc)", 'ruby/1.9')
+    exp = root[0]
+
+    expect(exp).to be_instance_of(Backreference::NumberCallRelative)
+    expect(exp.number).to eq 1
+  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
+
+  specify('parse backref name recursion level ab') do
+    root = RP.parse('(?<X>abc)\\k<X-0>', 'ruby/1.9')
+    exp = root[1]
+
+    expect(exp).to be_instance_of(Backreference::NameRecursionLevel)
+    expect(exp.name).to eq 'X'
+    expect(exp.recursion_level).to eq 0
+  end
+
+  specify('parse backref name recursion level sq') do
+    root = RP.parse("(?<X>abc)\\k'X-0'", 'ruby/1.9')
+    exp = root[1]
+
+    expect(exp).to be_instance_of(Backreference::NameRecursionLevel)
+    expect(exp.name).to eq 'X'
+    expect(exp.recursion_level).to eq 0
+  end
+
+  specify('parse backref number recursion level ab') do
+    root = RP.parse('(abc)\\k<1-0>', 'ruby/1.9')
+    exp = root[1]
+
+    expect(exp).to be_instance_of(Backreference::NumberRecursionLevel)
+    expect(exp.number).to eq 1
+    expect(exp.recursion_level).to eq 0
+  end
+
+  specify('parse backref number recursion level sq') do
+    root = RP.parse("(abc)\\k'1-0'", 'ruby/1.9')
+    exp = root[1]
+
+    expect(exp).to be_instance_of(Backreference::NumberRecursionLevel)
+    expect(exp.number).to eq 1
+    expect(exp.recursion_level).to eq 0
+  end
+
+  specify('parse backref negative number recursion level') do
+    root = RP.parse("(abc)\\k'-1+0'", 'ruby/1.9')
+    exp = root[1]
+
+    expect(exp).to be_instance_of(Backreference::NumberRecursionLevel)
+    expect(exp.number).to eq(-1)
+    expect(exp.recursion_level).to eq 0
+  end
+
+  specify('parse backref number positive recursion level') do
+    root = RP.parse("(abc)\\k'1+1'", 'ruby/1.9')
+    exp = root[1]
+
+    expect(exp).to be_instance_of(Backreference::NumberRecursionLevel)
+    expect(exp.number).to eq 1
+    expect(exp.recursion_level).to eq 1
+  end
+
+  specify('parse backref number negative recursion level') do
+    root = RP.parse("(abc)\\k'1-1'", 'ruby/1.9')
+    exp = root[1]
+
+    expect(exp).to be_instance_of(Backreference::NumberRecursionLevel)
+    expect(exp.number).to eq 1
+    expect(exp.recursion_level).to eq(-1)
+  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('SetIntersection 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.matches?('a')).to be false
+    expect(set.matches?('&')).to be false
+    expect(set.matches?('z')).to be false
+  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.matches?('a')).to be false
+    expect(set.matches?('&')).to be false
+    expect(set.matches?('b')).to be true
+  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.matches?('a')).to be true
+    expect(set.matches?('&')).to be false
+    expect(set.matches?('b')).to be false
+  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.matches?('a')).to be true
+    expect(set.matches?('&')).to be false
+    expect(set.matches?('b')).to be false
+  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.matches?('e')).to be true
+    expect(set.matches?('f')).to be true
+    expect(set.matches?('a')).to be false
+    expect(set.matches?('g')).to be false
+  end
+end

data/spec/parser/set/ranges_spec.rb

@@ -0,0 +1,111 @@
+require 'spec_helper'
+
+RSpec.describe('SetRang 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.matches?('m')).to be true
+  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.matches?('\\x50')).to be true
+  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.matches?('\\u600')).to be true
+  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.matches?('a')).to be true
+  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.matches?('$')).to be true
+  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.matches?('a')).to be true
+    expect(set.matches?('z')).to be false
+  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.matches?('$')).to be true
+  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.matches?('-')).to be true
+    expect(set.matches?('b')).to be true
+    expect(set.matches?('a')).to be false
+    expect(set.matches?('c')).to be false
+  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.matches?('-')).to be true
+    expect(set.matches?('b')).to be true
+    expect(set.matches?('a')).to be false
+    expect(set.matches?('c')).to be false
+  end
+end