regexp_parser 1.5.0 → 1.5.1

data/spec/parser/keep_spec.rb

@@ -1,19 +1,6 @@
 require 'spec_helper'
 
 RSpec.describe('Keep parsing') do
-  specify('parse keep') do
-    regexp = /ab\Kcd/
-    root = RP.parse(regexp)
-
-    expect(root[1]).to be_instance_of(Keep::Mark)
-    expect(root[1].text).to eq '\\K'
-  end
-
-  specify('parse keep nested') do
-    regexp = /(a\\\Kb)/
-    root = RP.parse(regexp)
-
-    expect(root[0][2]).to be_instance_of(Keep::Mark)
-    expect(root[0][2].text).to eq '\\K'
-  end
+  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

@@ -1,27 +1,8 @@
 require 'spec_helper'
 
-RSpec.describe('PosixClasse parsing') do
-  specify('parse posix class') do
-    root = RP.parse('[[:word:]]')
-    exp = root[0][0]
-
-    expect(exp).to be_instance_of(PosixClass)
-    expect(exp.type).to eq :posixclass
-    expect(exp.token).to eq :word
-    expect(exp.name).to eq 'word'
-    expect(exp.text).to eq '[:word:]'
-    expect(exp).not_to be_negative
-  end
-
-  specify('parse negative posix class') do
-    root = RP.parse('[[:^word:]]')
-    exp = root[0][0]
-
-    expect(exp).to be_instance_of(PosixClass)
-    expect(exp.type).to eq :nonposixclass
-    expect(exp.token).to eq :word
-    expect(exp.name).to eq 'word'
-    expect(exp.text).to eq '[:^word:]'
-    expect(exp).to be_negative
-  end
+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

@@ -1,7 +1,6 @@
 require 'spec_helper'
 
 RSpec.describe('Property parsing') do
-  modes = %w[p P]
   example_props = [
     'Alnum',
     'Any',
@@ -20,108 +19,97 @@ RSpec.describe('Property parsing') do
     'InChessSymbols'
   ]
 
-  modes.each do |mode|
-    token_type = mode == 'p' ? :property : :nonproperty
+  example_props.each do |name|
+    it("parses property #{name}") do
+      exp = RP.parse("ab\\p{#{name}}", '*').last
 
-    example_props.each do |property|
-      specify("parse_#{token_type}_#{property}") do
-        t = RP.parse("ab\\#{mode}{#{property}}", '*')
+      expect(exp).to be_a(UnicodeProperty::Base)
+      expect(exp.type).to eq :property
+      expect(exp.name).to eq name
+    end
 
-        expect(t.expressions.last).to be_a(UnicodeProperty::Base)
+    it("parses nonproperty #{name}") do
+      exp = RP.parse("ab\\P{#{name}}", '*').last
 
-        expect(t.expressions.last.type).to eq token_type
-        expect(t.expressions.last.name).to eq property
-      end
+      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|
-      begin
-        RP.parse("\\p{#{prop}}")
-      rescue SyntaxError, StandardError
-        nil
-      end
+      RP.parse("\\p{#{prop}}") rescue false
     end
     expect(unsupported).to be_empty
   end
 
   specify('parse property negative') do
-    t = RP.parse('ab\\p{L}cd', 'ruby/1.9')
-
-    expect(t[1]).not_to be_negative
+    root = RP.parse('ab\p{L}cd', 'ruby/1.9')
+    expect(root[1]).not_to be_negative
   end
 
   specify('parse nonproperty negative') do
-    t = RP.parse('ab\\P{L}cd', 'ruby/1.9')
-
-    expect(t[1]).to be_negative
+    root = RP.parse('ab\P{L}cd', 'ruby/1.9')
+    expect(root[1]).to be_negative
   end
 
   specify('parse caret nonproperty negative') do
-    t = RP.parse('ab\\p{^L}cd', 'ruby/1.9')
-
-    expect(t[1]).to be_negative
+    root = RP.parse('ab\p{^L}cd', 'ruby/1.9')
+    expect(root[1]).to be_negative
   end
 
   specify('parse double negated property negative') do
-    t = RP.parse('ab\\P{^L}cd', 'ruby/1.9')
-
-    expect(t[1]).not_to be_negative
+    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{mark}')[0].shortcut).to eq 'm'
-    expect(RP.parse('\\p{sc}')[0].shortcut).to eq 'sc'
-    expect(RP.parse('\\p{in_bengali}')[0].shortcut).to be_nil
+    expect(RP.parse('\p{mark}')[0].shortcut).to eq 'm'
+    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
-    t = RP.parse('ab\\p{age=5.2}cd', 'ruby/1.9')
-
-    expect(t[1]).to be_a(UnicodeProperty::Age)
+    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
-    t = RP.parse('ab\\p{Math}cd', 'ruby/1.9')
-
-    expect(t[1]).to be_a(UnicodeProperty::Derived)
+    root = RP.parse('ab\p{Math}cd', 'ruby/1.9')
+    expect(root[1]).to be_a(UnicodeProperty::Derived)
   end
 
   specify('parse property script') do
-    t = RP.parse('ab\\p{Hiragana}cd', 'ruby/1.9')
-
-    expect(t[1]).to be_a(UnicodeProperty::Script)
+    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
-    t = RP.parse('ab\\p{Brahmi}cd', 'ruby/1.9.3')
-
-    expect(t[1]).to be_a(UnicodeProperty::Script)
+    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
-    t = RP.parse('ab\\p{Caucasian_Albanian}cd', 'ruby/2.2')
-
-    expect(t[1]).to be_a(UnicodeProperty::Script)
+    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
-    t = RP.parse('ab\\p{InArmenian}cd', 'ruby/1.9')
-
-    expect(t[1]).to be_a(UnicodeProperty::Block)
+    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
-    t = RP.parse('ab\\p{Lu}cd', 'ruby/1.9')
-
-    expect(t[2]).to be_a(Literal)
+    root = RP.parse('ab\p{Lu}cd', 'ruby/1.9')
+    expect(root[2]).to be_a(Literal)
   end
 
   specify('parse abandoned newline property') do
-    t = RP.parse('\\p{newline}', 'ruby/1.9')
-    expect(t.expressions.last).to be_a(UnicodeProperty::Base)
+    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)
+    expect { RP.parse('\p{newline}', 'ruby/2.0') }
+      .to raise_error(Regexp::Syntax::NotImplementedError)
   end
 end

data/spec/parser/quantifiers_spec.rb

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