regexp_parser 1.5.0 → 1.5.1

data/spec/parser/refcalls_spec.rb

@@ -1,61 +1,66 @@
 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
+  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')
@@ -76,76 +81,11 @@ RSpec.describe('Refcall parsing') do
     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]
@@ -153,7 +93,6 @@ RSpec.describe('Refcall parsing') do
     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
@@ -166,72 +105,8 @@ RSpec.describe('Refcall parsing') do
     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

@@ -2,7 +2,7 @@ require 'spec_helper'
 
 # edge cases with `...-&&...` and `...&&-...` are checked in test_ranges.rb
 
-RSpec.describe('SetIntersection parsing') do
+RSpec.describe('CharacterSet::Intersection parsing') do
   specify('parse set intersection') do
     root = RP.parse('[a&&z]')
     set = root[0]
@@ -22,9 +22,9 @@ RSpec.describe('SetIntersection parsing') do
     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
+    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
@@ -46,9 +46,9 @@ RSpec.describe('SetIntersection parsing') do
     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
+    expect(set).not_to match 'a'
+    expect(set).not_to match '&'
+    expect(set).to     match 'b'
   end
 
   specify('parse set intersection trailing range') do
@@ -70,9 +70,9 @@ RSpec.describe('SetIntersection parsing') do
     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
+    expect(set).to     match 'a'
+    expect(set).not_to match '&'
+    expect(set).not_to match 'b'
   end
 
   specify('parse set intersection type') do
@@ -94,9 +94,9 @@ RSpec.describe('SetIntersection parsing') do
     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
+    expect(set).to     match 'a'
+    expect(set).not_to match '&'
+    expect(set).not_to match 'b'
   end
 
   specify('parse set intersection multipart') do
@@ -119,9 +119,9 @@ RSpec.describe('SetIntersection parsing') do
     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
+    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,6 +1,6 @@
 require 'spec_helper'
 
-RSpec.describe('SetRang parsing') do
+RSpec.describe('CharacterSet::Range parsing') do
   specify('parse set range') do
     root = RP.parse('[a-z]')
     set = root[0]
@@ -13,7 +13,7 @@ RSpec.describe('SetRang parsing') do
     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
+    expect(set).to match 'm'
   end
 
   specify('parse set range hex') do
@@ -28,7 +28,7 @@ RSpec.describe('SetRang parsing') do
     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
+    expect(set).to match '\\x50'
   end
 
   specify('parse set range unicode') do
@@ -43,7 +43,7 @@ RSpec.describe('SetRang parsing') do
     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
+    expect(set).to match '\\u600'
   end
 
   specify('parse set range edge case leading dash') do
@@ -53,7 +53,7 @@ RSpec.describe('SetRang parsing') do
 
     expect(set.count).to eq 1
     expect(range.count).to eq 2
-    expect(set.matches?('a')).to be true
+    expect(set).to match 'a'
   end
 
   specify('parse set range edge case trailing dash') do
@@ -63,7 +63,7 @@ RSpec.describe('SetRang parsing') do
 
     expect(set.count).to eq 1
     expect(range.count).to eq 2
-    expect(set.matches?('$')).to be true
+    expect(set).to match '$'
   end
 
   specify('parse set range edge case leading negate') do
@@ -71,8 +71,8 @@ RSpec.describe('SetRang parsing') do
     set = root[0]
 
     expect(set.count).to eq 2
-    expect(set.matches?('a')).to be true
-    expect(set.matches?('z')).to be false
+    expect(set).to     match 'a'
+    expect(set).not_to match 'z'
   end
 
   specify('parse set range edge case trailing negate') do
@@ -82,7 +82,7 @@ RSpec.describe('SetRang parsing') do
 
     expect(set.count).to eq 1
     expect(range.count).to eq 2
-    expect(set.matches?('$')).to be true
+    expect(set).to match '$'
   end
 
   specify('parse set range edge case leading intersection') do
@@ -91,10 +91,10 @@ RSpec.describe('SetRang parsing') do
 
     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
+    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
@@ -103,9 +103,9 @@ RSpec.describe('SetRang parsing') do
 
     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
+    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,6 +1,6 @@
 require 'spec_helper'
 
-RSpec.describe('Set parsing') do
+RSpec.describe('CharacterSet parsing') do
   specify('parse set basic') do
     root = RP.parse('[ab]+')
     exp = root[0]
@@ -39,10 +39,10 @@ RSpec.describe('Set parsing') do
     expect(exp[1]).to be_instance_of(EscapeSequence::Backspace)
     expect(exp[1].text).to eq '\\b'
 
-    expect(exp.matches?('a')).to be true
-    expect(exp.matches?("\b")).to be true
-    expect(exp.matches?('b')).to be false
-    expect(exp.matches?('c')).to be true
+    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