regexp_parser 1.3.0 → 1.6.0

data/spec/expression/free_space_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+RSpec.describe(Regexp::Expression::FreeSpace) do
+  specify('white space quantify raises error') do
+    regexp = /
+      a # Comment
+    /x
+
+    root = RP.parse(regexp)
+    space = root[0]
+
+    expect(space).to be_instance_of(FreeSpace::WhiteSpace)
+    expect { space.quantify(:dummy, '#') }.to raise_error(RuntimeError)
+  end
+
+  specify('comment quantify raises error') do
+    regexp = /
+      a # Comment
+    /x
+
+    root = RP.parse(regexp)
+    comment = root[3]
+
+    expect(comment).to be_instance_of(FreeSpace::Comment)
+    expect { comment.quantify(:dummy, '#') }.to raise_error(RuntimeError)
+  end
+end

data/spec/expression/methods/match_length_spec.rb

@@ -0,0 +1,154 @@
+require 'spec_helper'
+
+RSpec.describe(Regexp::MatchLength) do
+  ML = described_class
+
+  specify('literal') { expect(ML.of(/a/).minmax).to eq [1, 1] }
+  specify('literal sequence') { expect(ML.of(/abc/).minmax).to eq [3, 3] }
+  specify('dot') { expect(ML.of(/./).minmax).to eq [1, 1] }
+  specify('set') { expect(ML.of(/[abc]/).minmax).to eq [1, 1] }
+  specify('type') { expect(ML.of(/\d/).minmax).to eq [1, 1] }
+  specify('escape') { expect(ML.of(/\n/).minmax).to eq [1, 1] }
+  specify('property') { expect(ML.of(/\p{ascii}/).minmax).to eq [1, 1] }
+  specify('codepoint list') { expect(ML.of(/\u{61 62 63}/).minmax).to eq [3, 3] }
+  specify('multi-char literal') { expect(ML.of(/abc/).minmax).to eq [3, 3] }
+  specify('fixed quantified') { expect(ML.of(/a{5}/).minmax).to eq [5, 5] }
+  specify('range quantified') { expect(ML.of(/a{5,9}/).minmax).to eq [5, 9] }
+  specify('nested quantified') { expect(ML.of(/(a{2}){3,4}/).minmax).to eq [6, 8] }
+  specify('open-end quantified') { expect(ML.of(/a*/).minmax).to eq [0, Float::INFINITY] }
+  specify('empty subexpression') { expect(ML.of(//).minmax).to eq [0, 0] }
+  specify('anchor') { expect(ML.of(/^$/).minmax).to eq [0, 0] }
+  specify('lookaround') { expect(ML.of(/(?=abc)/).minmax).to eq [0, 0] }
+  specify('free space') { expect(ML.of(/   /x).minmax).to eq [0, 0] }
+  specify('comment') { expect(ML.of(/(?#comment)/x).minmax).to eq [0, 0] }
+  specify('backreference') { expect(ML.of(/(abc){2}\1/).minmax).to eq [9, 9] }
+  specify('subexp call') { expect(ML.of(/(abc){2}\g<-1>/).minmax).to eq [9, 9] }
+  specify('alternation') { expect(ML.of(/a|bcde/).minmax).to eq [1, 4] }
+  specify('nested alternation') { expect(ML.of(/a|bc(d|efg)/).minmax).to eq [1, 5] }
+  specify('quantified alternation') { expect(ML.of(/a|bcde?/).minmax).to eq [1, 4] }
+  if ruby_version_at_least('2.4.1')
+    specify('absence group') { expect(ML.of('(?~abc)').minmax).to eq [0, Float::INFINITY] }
+  end
+
+  specify('raises for missing references') do
+    exp = RP.parse(/(a)\1/).last
+    exp.referenced_expression = nil
+    expect { exp.match_length }.to raise_error(ArgumentError)
+  end
+
+  describe('::of') do
+    it('works with Regexps') { expect(ML.of(/foo/).minmax).to eq [3, 3] }
+    it('works with Strings') { expect(ML.of('foo').minmax).to eq [3, 3] }
+    it('works with Expressions') { expect(ML.of(RP.parse(/foo/)).minmax).to eq [3, 3] }
+  end
+
+  describe('Expression#match_length') do
+    it('returns the MatchLength') { expect(RP.parse(/abc/).match_length.minmax).to eq [3, 3] }
+  end
+
+  describe('Expression#inner_match_length') do
+    it 'returns the MatchLength of an expression that does not count towards parent match_length' do
+      exp = RP.parse(/(?=ab|cdef)/)[0]
+      expect(exp).to be_a Regexp::Expression::Assertion::Base
+      expect(exp.match_length.minmax).to eq [0, 0]
+      expect(exp.inner_match_length.minmax).to eq [2, 4]
+    end
+  end
+
+  describe('#include?') do
+    specify('unquantified') do
+      expect(ML.of(/a/)).to include 1
+      expect(ML.of(/a/)).not_to include 0
+      expect(ML.of(/a/)).not_to include 2
+    end
+
+    specify('fixed quantified') do
+      expect(ML.of(/a{5}/)).to include 5
+      expect(ML.of(/a{5}/)).not_to include 0
+      expect(ML.of(/a{5}/)).not_to include 4
+      expect(ML.of(/a{5}/)).not_to include 6
+    end
+
+    specify('variably quantified') do
+      expect(ML.of(/a?/)).to include 0
+      expect(ML.of(/a?/)).to include 1
+      expect(ML.of(/a?/)).not_to include 2
+    end
+
+    specify('nested quantified') do
+      expect(ML.of(/(a{2}){3,4}/)).to include 6
+      expect(ML.of(/(a{2}){3,4}/)).to include 8
+      expect(ML.of(/(a{2}){3,4}/)).not_to include 0
+      expect(ML.of(/(a{2}){3,4}/)).not_to include 5
+      expect(ML.of(/(a{2}){3,4}/)).not_to include 7
+      expect(ML.of(/(a{2}){3,4}/)).not_to include 9
+    end
+
+    specify('branches') do
+      expect(ML.of(/ab|cdef/)).to include 2
+      expect(ML.of(/ab|cdef/)).to include 4
+      expect(ML.of(/ab|cdef/)).not_to include 0
+      expect(ML.of(/ab|cdef/)).not_to include 3
+      expect(ML.of(/ab|cdef/)).not_to include 5
+    end
+
+    specify('called on leaf node') do
+      expect(ML.of(RP.parse(/a{2}/)[0])).to include 2
+      expect(ML.of(RP.parse(/a{2}/)[0])).not_to include 0
+      expect(ML.of(RP.parse(/a{2}/)[0])).not_to include 1
+      expect(ML.of(RP.parse(/a{2}/)[0])).not_to include 3
+    end
+  end
+
+  describe('#fixed?') do
+    specify('unquantified') { expect(ML.of(/a/)).to be_fixed }
+    specify('fixed quantified') { expect(ML.of(/a{5}/)).to be_fixed }
+    specify('variably quantified') { expect(ML.of(/a?/)).not_to be_fixed }
+    specify('equal branches') { expect(ML.of(/ab|cd/)).to be_fixed }
+    specify('unequal branches') { expect(ML.of(/ab|cdef/)).not_to be_fixed }
+    specify('equal quantified branches') { expect(ML.of(/a{2}|cd/)).to be_fixed }
+    specify('unequal quantified branches') { expect(ML.of(/a{3}|cd/)).not_to be_fixed }
+    specify('empty') { expect(ML.of(//)).to be_fixed }
+  end
+
+  describe('#each') do
+    it 'returns an Enumerator if called without a block' do
+      result = ML.of(/a?/).each
+      expect(result).to be_a(Enumerator)
+      expect(result.next).to eq 0
+      expect(result.next).to eq 1
+      expect { result.next }.to raise_error(StopIteration)
+    end
+
+    it 'is limited to 1000 iterations in case there are infinite match lengths' do
+      expect(ML.of(/a*/).first(3000).size).to eq 1000
+    end
+
+    it 'scaffolds the Enumerable interface' do
+      expect(ML.of(/abc|defg/).count).to eq 2
+      expect(ML.of(/(ab)*/).first(5)).to eq [0, 2, 4, 6, 8]
+      expect(ML.of(/a{,10}/).any? { |len| len > 20 }).to be false
+    end
+  end
+
+  describe('#endless_each') do
+    it 'returns an Enumerator if called without a block' do
+      result = ML.of(/a?/).endless_each
+      expect(result).to be_a(Enumerator)
+      expect(result.next).to eq 0
+      expect(result.next).to eq 1
+      expect { result.next }.to raise_error(StopIteration)
+    end
+
+    it 'never stops iterating for infinite match lengths' do
+      expect(ML.of(/a*/).endless_each.first(3000).size).to eq 3000
+    end
+  end
+
+  describe('#inspect') do
+    it 'is nice' do
+      result = RP.parse(/a{2,4}/)[0].match_length
+      expect(result.inspect).to eq '#<Regexp::MatchLength<Literal> min=2 max=4>'
+    end
+  end
+end

data/spec/expression/methods/match_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+RSpec.describe('Expression#match') do
+  it 'returns the #match result of the respective Regexp' do
+    expect(RP.parse(/a/).match('a')[0]).to eq 'a'
+  end
+
+  it 'can be given an offset, just like Regexp#match' do
+    expect(RP.parse(/./).match('ab', 1)[0]).to eq 'b'
+  end
+
+  it 'works with the #=~ alias' do
+    expect(RP.parse(/a/) =~ 'a').to be_a MatchData
+  end
+end
+
+RSpec.describe('Expression#match?') do
+  it 'returns true if the Respective Regexp matches' do
+    expect(RP.parse(/a/).match?('a')).to be true
+  end
+
+  it 'returns false if the Respective Regexp does not match' do
+    expect(RP.parse(/a/).match?('b')).to be false
+  end
+end

data/spec/expression/methods/strfregexp_spec.rb

@@ -0,0 +1,224 @@
+require 'spec_helper'
+
+RSpec.describe('Expression#strfregexp') do
+  specify('#strfre alias') do
+    expect(RP.parse(/a/)).to respond_to(:strfre)
+  end
+
+  specify('#strfregexp level') do
+    root = RP.parse(/a(b(c))/)
+
+    expect(root.strfregexp('%l')).to eq 'root'
+
+    a = root.first
+    expect(a.strfregexp('%%l')).to eq '%0'
+
+    b = root[1].first
+    expect(b.strfregexp('<%l>')).to eq '<1>'
+
+    c = root[1][1].first
+    expect(c.strfregexp('[at: %l]')).to eq '[at: 2]'
+  end
+
+  specify('#strfregexp start end') do
+    root = RP.parse(/a(b(c))/)
+
+    expect(root.strfregexp('%s')).to eq '0'
+    expect(root.strfregexp('%e')).to eq '7'
+
+    a = root.first
+    expect(a.strfregexp('%%s')).to eq '%0'
+    expect(a.strfregexp('%e')).to eq '1'
+
+    group_1 = root[1]
+    expect(group_1.strfregexp('GRP:%s')).to eq 'GRP:1'
+    expect(group_1.strfregexp('%e')).to eq '7'
+
+    b = group_1.first
+    expect(b.strfregexp('<@%s>')).to eq '<@2>'
+    expect(b.strfregexp('%e')).to eq '3'
+
+    c = group_1.last.first
+    expect(c.strfregexp('[at: %s]')).to eq '[at: 4]'
+    expect(c.strfregexp('%e')).to eq '5'
+  end
+
+  specify('#strfregexp length') do
+    root = RP.parse(/a[b]c/)
+
+    expect(root.strfregexp('%S')).to eq '5'
+
+    a = root.first
+    expect(a.strfregexp('%S')).to eq '1'
+
+    set = root[1]
+    expect(set.strfregexp('%S')).to eq '3'
+  end
+
+  specify('#strfregexp coded offset') do
+    root = RP.parse(/a[b]c/)
+
+    expect(root.strfregexp('%o')).to eq '@0+5'
+
+    a = root.first
+    expect(a.strfregexp('%o')).to eq '@0+1'
+
+    set = root[1]
+    expect(set.strfregexp('%o')).to eq '@1+3'
+  end
+
+  specify('#strfregexp type token') do
+    root = RP.parse(/a[b](c)/)
+
+    expect(root.strfregexp('%y')).to eq 'expression'
+    expect(root.strfregexp('%k')).to eq 'root'
+    expect(root.strfregexp('%i')).to eq 'expression:root'
+    expect(root.strfregexp('%c')).to eq 'Regexp::Expression::Root'
+
+    a = root.first
+    expect(a.strfregexp('%y')).to eq 'literal'
+    expect(a.strfregexp('%k')).to eq 'literal'
+    expect(a.strfregexp('%i')).to eq 'literal:literal'
+    expect(a.strfregexp('%c')).to eq 'Regexp::Expression::Literal'
+
+    set = root[1]
+    expect(set.strfregexp('%y')).to eq 'set'
+    expect(set.strfregexp('%k')).to eq 'character'
+    expect(set.strfregexp('%i')).to eq 'set:character'
+    expect(set.strfregexp('%c')).to eq 'Regexp::Expression::CharacterSet'
+
+    group = root.last
+    expect(group.strfregexp('%y')).to eq 'group'
+    expect(group.strfregexp('%k')).to eq 'capture'
+    expect(group.strfregexp('%i')).to eq 'group:capture'
+    expect(group.strfregexp('%c')).to eq 'Regexp::Expression::Group::Capture'
+  end
+
+  specify('#strfregexp quantifier') do
+    root = RP.parse(/a+[b](c)?d{3,4}/)
+
+    expect(root.strfregexp('%q')).to eq '{1}'
+    expect(root.strfregexp('%Q')).to eq ''
+    expect(root.strfregexp('%z, %Z')).to eq '1, 1'
+
+    a = root.first
+    expect(a.strfregexp('%q')).to eq '{1, or-more}'
+    expect(a.strfregexp('%Q')).to eq '+'
+    expect(a.strfregexp('%z, %Z')).to eq '1, -1'
+
+    set = root[1]
+    expect(set.strfregexp('%q')).to eq '{1}'
+    expect(set.strfregexp('%Q')).to eq ''
+    expect(set.strfregexp('%z, %Z')).to eq '1, 1'
+
+    group = root[2]
+    expect(group.strfregexp('%q')).to eq '{0, 1}'
+    expect(group.strfregexp('%Q')).to eq '?'
+    expect(group.strfregexp('%z, %Z')).to eq '0, 1'
+
+    d = root.last
+    expect(d.strfregexp('%q')).to eq '{3, 4}'
+    expect(d.strfregexp('%Q')).to eq '{3,4}'
+    expect(d.strfregexp('%z, %Z')).to eq '3, 4'
+  end
+
+  specify('#strfregexp text') do
+    root = RP.parse(/a(b(c))|[d-gk-p]+/)
+
+    expect(root.strfregexp('%t')).to eq 'a(b(c))|[d-gk-p]+'
+    expect(root.strfregexp('%~t')).to eq 'expression:root'
+
+    alt = root.first
+    expect(alt.strfregexp('%t')).to eq 'a(b(c))|[d-gk-p]+'
+    expect(alt.strfregexp('%T')).to eq 'a(b(c))|[d-gk-p]+'
+    expect(alt.strfregexp('%~t')).to eq 'meta:alternation'
+
+    seq_1 = alt.first
+    expect(seq_1.strfregexp('%t')).to eq 'a(b(c))'
+    expect(seq_1.strfregexp('%T')).to eq 'a(b(c))'
+    expect(seq_1.strfregexp('%~t')).to eq 'expression:sequence'
+
+    group = seq_1[1]
+    expect(group.strfregexp('%t')).to eq '(b(c))'
+    expect(group.strfregexp('%T')).to eq '(b(c))'
+    expect(group.strfregexp('%~t')).to eq 'group:capture'
+
+    seq_2 = alt.last
+    expect(seq_2.strfregexp('%t')).to eq '[d-gk-p]+'
+    expect(seq_2.strfregexp('%T')).to eq '[d-gk-p]+'
+
+    set = seq_2.first
+    expect(set.strfregexp('%t')).to eq '[d-gk-p]'
+    expect(set.strfregexp('%T')).to eq '[d-gk-p]+'
+    expect(set.strfregexp('%~t')).to eq 'set:character'
+  end
+
+  specify('#strfregexp combined') do
+    root = RP.parse(/a{5}|[b-d]+/)
+
+    expect(root.strfregexp('%b')).to eq '@0+11 expression:root'
+    expect(root.strfregexp('%b')).to eq root.strfregexp('%o %i')
+
+    expect(root.strfregexp('%m')).to eq '@0+11 expression:root {1}'
+    expect(root.strfregexp('%m')).to eq root.strfregexp('%b %q')
+
+    expect(root.strfregexp('%a')).to eq '@0+11 expression:root {1} a{5}|[b-d]+'
+    expect(root.strfregexp('%a')).to eq root.strfregexp('%m %t')
+  end
+
+  specify('#strfregexp conditional') do
+    root = RP.parse('(?<A>a)(?(<A>)b|c)', 'ruby/2.0')
+
+    expect { root.strfregexp }.not_to(raise_error)
+  end
+
+  specify('#strfregexp_tree') do
+    root = RP.parse(/a[b-d]*(e(f+))?/)
+
+    expect(root.strfregexp_tree('%>%o %~t')).to eq(
+      "@0+15 expression:root\n" +
+      "  @0+1 a\n" +
+      "  @1+6 set:character\n" +
+      "    @2+3 set:range\n" +
+      "      @2+1 b\n" +
+      "      @4+1 d\n" +
+      "  @7+8 group:capture\n" +
+      "    @8+1 e\n" +
+      "    @9+4 group:capture\n" +
+      "      @10+2 f+"
+    )
+  end
+
+  specify('#strfregexp_tree separator') do
+    root = RP.parse(/a[b-d]*(e(f+))?/)
+
+    expect(root.strfregexp_tree('%>%o %~t', true, '-SEP-')).to eq(
+      "@0+15 expression:root-SEP-" +
+      "  @0+1 a-SEP-" +
+      "  @1+6 set:character-SEP-" +
+      "    @2+3 set:range-SEP-" +
+      "      @2+1 b-SEP-" +
+      "      @4+1 d-SEP-" +
+      "  @7+8 group:capture-SEP-" +
+      "    @8+1 e-SEP-" +
+      "    @9+4 group:capture-SEP-" +
+      "      @10+2 f+"
+    )
+  end
+
+  specify('#strfregexp_tree excluding self') do
+    root = RP.parse(/a[b-d]*(e(f+))?/)
+
+    expect(root.strfregexp_tree('%>%o %~t', false)).to eq(
+      "@0+1 a\n" +
+      "@1+6 set:character\n" +
+      "  @2+3 set:range\n" +
+      "    @2+1 b\n" +
+      "    @4+1 d\n" +
+      "@7+8 group:capture\n" +
+      "  @8+1 e\n" +
+      "  @9+4 group:capture\n" +
+      "    @10+2 f+"
+    )
+  end
+end

data/spec/expression/methods/tests_spec.rb

@@ -0,0 +1,99 @@
+require 'spec_helper'
+
+RSpec.describe('ExpressionTests') do
+  specify('#type?') do
+    root = RP.parse(/abcd|(ghij)|[klmn]/)
+
+    alt = root.first
+
+    expect(alt.type?(:meta)).to be true
+    expect(alt.type?(:escape)).to be false
+    expect(alt.type?(%i[meta escape])).to be true
+    expect(alt.type?(%i[literal escape])).to be false
+    expect(alt.type?(:*)).to be true
+    expect(alt.type?([:*])).to be true
+    expect(alt.type?(%i[literal escape *])).to be true
+
+    seq_1 = alt[0]
+    expect(seq_1.type?(:expression)).to be true
+    expect(seq_1.first.type?(:literal)).to be true
+
+    seq_2 = alt[1]
+    expect(seq_2.type?(:*)).to be true
+    expect(seq_2.first.type?(:group)).to be true
+
+    seq_3 = alt[2]
+    expect(seq_3.first.type?(:set)).to be true
+  end
+
+  specify('#is?') do
+    root = RP.parse(/.+|\.?/)
+
+    expect(root.is?(:*)).to be true
+
+    alt = root.first
+    expect(alt.is?(:*)).to be true
+    expect(alt.is?(:alternation)).to be true
+    expect(alt.is?(:alternation, :meta)).to be true
+
+    seq_1 = alt[0]
+    expect(seq_1.is?(:sequence)).to be true
+    expect(seq_1.is?(:sequence, :expression)).to be true
+
+    expect(seq_1.first.is?(:dot)).to be true
+    expect(seq_1.first.is?(:dot, :escape)).to be false
+    expect(seq_1.first.is?(:dot, :meta)).to be true
+    expect(seq_1.first.is?(:dot, %i[escape meta])).to be true
+
+    seq_2 = alt[1]
+    expect(seq_2.first.is?(:dot)).to be true
+    expect(seq_2.first.is?(:dot, :escape)).to be true
+    expect(seq_2.first.is?(:dot, :meta)).to be false
+    expect(seq_2.first.is?(:dot, %i[meta escape])).to be true
+  end
+
+  specify('#one_of?') do
+    root = RP.parse(/\Aab(c[\w])d|e.\z/)
+
+    expect(root.one_of?(:*)).to be true
+    expect(root.one_of?(:* => :*)).to be true
+    expect(root.one_of?(:* => [:*])).to be true
+
+    alt = root.first
+    expect(alt.one_of?(:*)).to be true
+    expect(alt.one_of?(:meta)).to be true
+    expect(alt.one_of?(:meta, :alternation)).to be true
+    expect(alt.one_of?(meta: %i[dot bogus])).to be false
+    expect(alt.one_of?(meta: %i[dot alternation])).to be true
+
+    seq_1 = alt[0]
+    expect(seq_1.one_of?(:expression)).to be true
+    expect(seq_1.one_of?(expression: :sequence)).to be true
+
+    expect(seq_1.first.one_of?(:anchor)).to be true
+    expect(seq_1.first.one_of?(anchor: :bos)).to be true
+    expect(seq_1.first.one_of?(anchor: :eos)).to be false
+    expect(seq_1.first.one_of?(anchor: %i[escape meta bos])).to be true
+    expect(seq_1.first.one_of?(anchor: %i[escape meta eos])).to be false
+
+    seq_2 = alt[1]
+    expect(seq_2.first.one_of?(:literal)).to be true
+
+    expect(seq_2[1].one_of?(:meta)).to be true
+    expect(seq_2[1].one_of?(meta: :dot)).to be true
+    expect(seq_2[1].one_of?(meta: :alternation)).to be false
+    expect(seq_2[1].one_of?(meta: [:dot])).to be true
+
+    expect(seq_2.last.one_of?(:group)).to be false
+    expect(seq_2.last.one_of?(group: [:*])).to be false
+    expect(seq_2.last.one_of?(group: [:*], meta: :*)).to be false
+
+    expect(seq_2.last.one_of?(:meta => [:*], :* => :*)).to be true
+    expect(seq_2.last.one_of?(meta: [:*], anchor: :*)).to be true
+    expect(seq_2.last.one_of?(meta: [:*], anchor: :eos)).to be true
+    expect(seq_2.last.one_of?(meta: [:*], anchor: [:bos])).to be false
+    expect(seq_2.last.one_of?(meta: [:*], anchor: %i[bos eos])).to be true
+
+    expect { root.one_of?(Object.new) }.to raise_error(ArgumentError)
+  end
+end