regexp_parser 1.5.0 → 1.8.0

data/spec/parser/quantifiers_spec.rb

@@ -1,293 +1,52 @@
 require 'spec_helper'
 
 RSpec.describe('Quantifier parsing') do
-  specify('parse zero or one greedy') do
-    root = RP.parse('a?bc')
-    exp = root.expressions.first
+  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
+  include_examples 'quantifier', /a{004}+b/, '{004}+', :possessive, :interval,     4, 4
+
+  specify('mode-checking methods') do
+    exp = RP.parse(/a??/).first
 
-    expect(exp).to be_quantified
-    expect(exp.quantifier.token).to eq :zero_or_one
-    expect(exp.quantifier.min).to eq 0
-    expect(exp.quantifier.max).to eq 1
-    expect(exp.quantifier.mode).to eq :greedy
-    expect(exp.quantifier).to be_greedy
-    expect(exp).to be_greedy
-
-    expect(exp.quantifier).not_to be_reluctant
-    expect(exp).not_to be_reluctant
-    expect(exp.quantifier).not_to be_possessive
-    expect(exp).not_to be_possessive
-  end
-
-  specify('parse zero or one reluctant') do
-    root = RP.parse('a??bc')
-    exp = root.expressions.first
-
-    expect(exp).to be_quantified
-    expect(exp.quantifier.token).to eq :zero_or_one
-    expect(exp.quantifier.min).to eq 0
-    expect(exp.quantifier.max).to eq 1
-    expect(exp.quantifier.mode).to eq :reluctant
-    expect(exp.quantifier).to be_reluctant
     expect(exp).to be_reluctant
-
-    expect(exp.quantifier).not_to be_greedy
+    expect(exp).to be_lazy
     expect(exp).not_to be_greedy
-    expect(exp.quantifier).not_to be_possessive
     expect(exp).not_to be_possessive
-  end
-
-  specify('parse zero or one possessive') do
-    root = RP.parse('a?+bc', 'ruby/1.9')
-    exp = root.expressions.first
-
-    expect(exp).to be_quantified
-    expect(exp.quantifier.token).to eq :zero_or_one
-    expect(exp.quantifier.min).to eq 0
-    expect(exp.quantifier.max).to eq 1
-    expect(exp.quantifier.mode).to eq :possessive
-    expect(exp.quantifier).to be_possessive
-    expect(exp).to be_possessive
-
-    expect(exp.quantifier).not_to be_greedy
-    expect(exp).not_to be_greedy
-    expect(exp.quantifier).not_to be_reluctant
-    expect(exp).not_to be_reluctant
-  end
-
-  specify('parse zero or more greedy') do
-    root = RP.parse('a*bc')
-    exp = root.expressions.first
-
-    expect(exp).to be_quantified
-    expect(exp.quantifier.token).to eq :zero_or_more
-    expect(exp.quantifier.min).to eq 0
-    expect(exp.quantifier.max).to eq(-1)
-    expect(exp.quantifier.mode).to eq :greedy
-    expect(exp.quantifier).to be_greedy
-    expect(exp).to be_greedy
-  end
-
-  specify('parse zero or more reluctant') do
-    root = RP.parse('a*?bc')
-    exp = root.expressions.first
-
-    expect(exp).to be_quantified
-    expect(exp.quantifier.token).to eq :zero_or_more
-    expect(exp.quantifier.min).to eq 0
-    expect(exp.quantifier.max).to eq(-1)
-    expect(exp.quantifier.mode).to eq :reluctant
     expect(exp.quantifier).to be_reluctant
-    expect(exp).to be_reluctant
-  end
-
-  specify('parse zero or more possessive') do
-    root = RP.parse('a*+bc', 'ruby/1.9')
-    exp = root.expressions.first
-
-    expect(exp).to be_quantified
-    expect(exp.quantifier.token).to eq :zero_or_more
-    expect(exp.quantifier.min).to eq 0
-    expect(exp.quantifier.max).to eq(-1)
-    expect(exp.quantifier.mode).to eq :possessive
-    expect(exp.quantifier).to be_possessive
-    expect(exp).to be_possessive
-  end
-
-  specify('parse one or more greedy') do
-    root = RP.parse('a+bc')
-    exp = root.expressions.first
-
-    expect(exp).to be_quantified
-    expect(exp.quantifier.token).to eq :one_or_more
-    expect(exp.quantifier.min).to eq 1
-    expect(exp.quantifier.max).to eq(-1)
-    expect(exp.quantifier.mode).to eq :greedy
-    expect(exp.quantifier).to be_greedy
-    expect(exp).to be_greedy
-  end
-
-  specify('parse one or more reluctant') do
-    root = RP.parse('a+?bc')
-    exp = root.expressions.first
-
-    expect(exp).to be_quantified
-    expect(exp.quantifier.token).to eq :one_or_more
-    expect(exp.quantifier.min).to eq 1
-    expect(exp.quantifier.max).to eq(-1)
-    expect(exp.quantifier.mode).to eq :reluctant
-    expect(exp.quantifier).to be_reluctant
-    expect(exp).to be_reluctant
-  end
-
-  specify('parse one or more possessive') do
-    root = RP.parse('a++bc', 'ruby/1.9')
-    exp = root.expressions.first
-
-    expect(exp).to be_quantified
-    expect(exp.quantifier.token).to eq :one_or_more
-    expect(exp.quantifier.min).to eq 1
-    expect(exp.quantifier.max).to eq(-1)
-    expect(exp.quantifier.mode).to eq :possessive
-    expect(exp.quantifier).to be_possessive
-    expect(exp).to be_possessive
-  end
-
-  specify('parse intervals min max greedy') do
-    root = RP.parse('a{2,4}bc')
-    exp = root.expressions.first
-
-    expect(exp).to be_quantified
-    expect(exp.quantifier.token).to eq :interval
-    expect(exp.quantifier.min).to eq 2
-    expect(exp.quantifier.max).to eq 4
-    expect(exp.quantifier.mode).to eq :greedy
-    expect(exp.quantifier).to be_greedy
-    expect(exp).to be_greedy
-  end
-
-  specify('parse intervals min max reluctant') do
-    root = RP.parse('a{3,5}?bc')
-    exp = root.expressions.first
-
-    expect(exp).to be_quantified
-    expect(exp.quantifier.token).to eq :interval
-    expect(exp.quantifier.min).to eq 3
-    expect(exp.quantifier.max).to eq 5
-    expect(exp.quantifier.mode).to eq :reluctant
-    expect(exp.quantifier).to be_reluctant
-    expect(exp).to be_reluctant
-  end
-
-  specify('parse intervals min max possessive') do
-    root = RP.parse('a{2,4}+bc', 'ruby/1.9')
-    exp = root.expressions.first
-
-    expect(exp).to be_quantified
-    expect(exp.quantifier.token).to eq :interval
-    expect(exp.quantifier.min).to eq 2
-    expect(exp.quantifier.max).to eq 4
-    expect(exp.quantifier.mode).to eq :possessive
-    expect(exp.quantifier).to be_possessive
-    expect(exp).to be_possessive
-  end
-
-  specify('parse intervals min only greedy') do
-    root = RP.parse('a{2,}bc')
-    exp = root.expressions.first
-
-    expect(exp).to be_quantified
-    expect(exp.quantifier.token).to eq :interval
-    expect(exp.quantifier.min).to eq 2
-    expect(exp.quantifier.max).to eq(-1)
-    expect(exp.quantifier.mode).to eq :greedy
-    expect(exp.quantifier).to be_greedy
-    expect(exp).to be_greedy
-  end
-
-  specify('parse intervals min only reluctant') do
-    root = RP.parse('a{2,}?bc')
-    exp = root.expressions.first
-
-    expect(exp).to be_quantified
-    expect(exp.quantifier.token).to eq :interval
-    expect(exp.quantifier.text).to eq '{2,}?'
-    expect(exp.quantifier.min).to eq 2
-    expect(exp.quantifier.max).to eq(-1)
-    expect(exp.quantifier.mode).to eq :reluctant
-    expect(exp.quantifier).to be_reluctant
-    expect(exp).to be_reluctant
-  end
-
-  specify('parse intervals min only possessive') do
-    root = RP.parse('a{3,}+bc', 'ruby/1.9')
-    exp = root.expressions.first
-
-    expect(exp).to be_quantified
-    expect(exp.quantifier.token).to eq :interval
-    expect(exp.quantifier.text).to eq '{3,}+'
-    expect(exp.quantifier.min).to eq 3
-    expect(exp.quantifier.max).to eq(-1)
-    expect(exp.quantifier.mode).to eq :possessive
-    expect(exp.quantifier).to be_possessive
-    expect(exp).to be_possessive
-  end
-
-  specify('parse intervals max only greedy') do
-    root = RP.parse('a{,2}bc')
-    exp = root.expressions.first
-
-    expect(exp).to be_quantified
-    expect(exp.quantifier.token).to eq :interval
-    expect(exp.quantifier.min).to eq 0
-    expect(exp.quantifier.max).to eq 2
-    expect(exp.quantifier.mode).to eq :greedy
-    expect(exp.quantifier).to be_greedy
-    expect(exp).to be_greedy
-  end
-
-  specify('parse intervals max only reluctant') do
-    root = RP.parse('a{,4}?bc')
-    exp = root.expressions.first
-
-    expect(exp).to be_quantified
-    expect(exp.quantifier.token).to eq :interval
-    expect(exp.quantifier.min).to eq 0
-    expect(exp.quantifier.max).to eq 4
-    expect(exp.quantifier.mode).to eq :reluctant
-    expect(exp.quantifier).to be_reluctant
-    expect(exp).to be_reluctant
-  end
-
-  specify('parse intervals max only possessive') do
-    root = RP.parse('a{,3}+bc', 'ruby/1.9')
-    exp = root.expressions.first
-
-    expect(exp).to be_quantified
-    expect(exp.quantifier.token).to eq :interval
-    expect(exp.quantifier.min).to eq 0
-    expect(exp.quantifier.max).to eq 3
-    expect(exp.quantifier.mode).to eq :possessive
-    expect(exp.quantifier).to be_possessive
-    expect(exp).to be_possessive
-  end
-
-  specify('parse intervals exact greedy') do
-    root = RP.parse('a{2}bc')
-    exp = root.expressions.first
-
-    expect(exp).to be_quantified
-    expect(exp.quantifier.token).to eq :interval
-    expect(exp.quantifier.min).to eq 2
-    expect(exp.quantifier.max).to eq 2
-    expect(exp.quantifier.mode).to eq :greedy
-    expect(exp.quantifier).to be_greedy
-    expect(exp).to be_greedy
-  end
-
-  specify('parse intervals exact reluctant') do
-    root = RP.parse('a{3}?bc')
-    exp = root.expressions.first
-
-    expect(exp).to be_quantified
-    expect(exp.quantifier.token).to eq :interval
-    expect(exp.quantifier.min).to eq 3
-    expect(exp.quantifier.max).to eq 3
-    expect(exp.quantifier.mode).to eq :reluctant
-    expect(exp.quantifier).to be_reluctant
-    expect(exp).to be_reluctant
-  end
-
-  specify('parse intervals exact possessive') do
-    root = RP.parse('a{3}+bc', 'ruby/1.9')
-    exp = root.expressions.first
-
-    expect(exp).to be_quantified
-    expect(exp.quantifier.token).to eq :interval
-    expect(exp.quantifier.min).to eq 3
-    expect(exp.quantifier.max).to eq 3
-    expect(exp.quantifier.mode).to eq :possessive
-    expect(exp.quantifier).to be_possessive
-    expect(exp).to be_possessive
+    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,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