regexp_parser 1.4.0 → 1.5.0

data/spec/parser/keep_spec.rb

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

data/spec/parser/posix_classes_spec.rb

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

data/spec/parser/properties_spec.rb

@@ -0,0 +1,127 @@
+require 'spec_helper'
+
+RSpec.describe('Property parsing') do
+  modes = %w[p P]
+  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'
+  ]
+
+  modes.each do |mode|
+    token_type = mode == 'p' ? :property : :nonproperty
+
+    example_props.each do |property|
+      specify("parse_#{token_type}_#{property}") do
+        t = RP.parse("ab\\#{mode}{#{property}}", '*')
+
+        expect(t.expressions.last).to be_a(UnicodeProperty::Base)
+
+        expect(t.expressions.last.type).to eq token_type
+        expect(t.expressions.last.name).to eq property
+      end
+    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
+    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
+  end
+
+  specify('parse nonproperty negative') do
+    t = RP.parse('ab\\P{L}cd', 'ruby/1.9')
+
+    expect(t[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
+  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
+  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
+  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)
+  end
+
+  specify('parse property derived') do
+    t = RP.parse('ab\\p{Math}cd', 'ruby/1.9')
+
+    expect(t[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)
+  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)
+  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)
+  end
+
+  specify('parse property block') do
+    t = RP.parse('ab\\p{InArmenian}cd', 'ruby/1.9')
+
+    expect(t[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)
+  end
+
+  specify('parse abandoned newline property') do
+    t = RP.parse('\\p{newline}', 'ruby/1.9')
+    expect(t.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

@@ -0,0 +1,293 @@
+require 'spec_helper'
+
+RSpec.describe('Quantifier parsing') do
+  specify('parse zero or one greedy') 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 :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).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
+  end
+end