regexp_parser 2.1.1 → 2.2.1

data/spec/expression/base_spec.rb

@@ -1,104 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe(Regexp::Expression::Base) do
-  specify('#to_re') do
-    re_text = '^a*(b([cde]+))+f?$'
-
-    re = RP.parse(re_text).to_re
-
-    expect(re).to be_a(::Regexp)
-    expect(re_text).to eq re.source
-  end
-
-  specify('#level') do
-    regexp = /^a(b(c(d)))e$/
-    root = RP.parse(regexp)
-
-    ['^', 'a', '(b(c(d)))', 'e', '$'].each_with_index do |t, i|
-      expect(root[i].to_s).to eq t
-      expect(root[i].level).to eq 0
-    end
-
-    expect(root[2][0].to_s).to eq 'b'
-    expect(root[2][0].level).to eq 1
-
-    expect(root[2][1][0].to_s).to eq 'c'
-    expect(root[2][1][0].level).to eq 2
-
-    expect(root[2][1][1][0].to_s).to eq 'd'
-    expect(root[2][1][1][0].level).to eq 3
-  end
-
-  specify('#terminal?') do
-    root = RP.parse('^a([b]+)c$')
-
-    expect(root).not_to be_terminal
-
-    expect(root[0]).to be_terminal
-    expect(root[1]).to be_terminal
-    expect(root[2]).not_to be_terminal
-    expect(root[2][0]).not_to be_terminal
-    expect(root[2][0][0]).to be_terminal
-    expect(root[3]).to be_terminal
-    expect(root[4]).to be_terminal
-  end
-
-  specify('alt #terminal?') do
-    root = RP.parse('^(ab|cd)$')
-
-    expect(root).not_to be_terminal
-
-    expect(root[0]).to be_terminal
-    expect(root[1]).not_to be_terminal
-    expect(root[1][0]).not_to be_terminal
-    expect(root[1][0][0]).not_to be_terminal
-    expect(root[1][0][0][0]).to be_terminal
-    expect(root[1][0][1]).not_to be_terminal
-    expect(root[1][0][1][0]).to be_terminal
-  end
-
-  specify('#coded_offset') do
-    root = RP.parse('^a*(b+(c?))$')
-
-    expect(root.coded_offset).to eq '@0+12'
-
-    [
-      ['@0+1', '^'],
-      ['@1+2', 'a*'],
-      ['@3+8', '(b+(c?))'],
-      ['@11+1', '$'],
-    ].each_with_index do |check, i|
-      against = [root[i].coded_offset, root[i].to_s]
-
-      expect(against).to eq check
-    end
-
-    expect([root[2][0].coded_offset, root[2][0].to_s]).to eq ['@4+2', 'b+']
-    expect([root[2][1].coded_offset, root[2][1].to_s]).to eq ['@6+4', '(c?)']
-    expect([root[2][1][0].coded_offset, root[2][1][0].to_s]).to eq ['@7+2', 'c?']
-  end
-
-  specify('#quantity') do
-    expect(RP.parse(/aa/)[0].quantity).to eq [nil, nil]
-    expect(RP.parse(/a?/)[0].quantity).to eq [0, 1]
-    expect(RP.parse(/a*/)[0].quantity).to eq [0, -1]
-    expect(RP.parse(/a+/)[0].quantity).to eq [1, -1]
-  end
-
-  specify('#repetitions') do
-    expect(RP.parse(/aa/)[0].repetitions).to eq 1..1
-    expect(RP.parse(/a?/)[0].repetitions).to eq 0..1
-    expect(RP.parse(/a*/)[0].repetitions).to eq 0..(Float::INFINITY)
-    expect(RP.parse(/a+/)[0].repetitions).to eq 1..(Float::INFINITY)
-  end
-
-  specify('#base_length') do
-    expect(RP.parse(/(aa)/)[0].base_length).to eq 4
-    expect(RP.parse(/(aa){42}/)[0].base_length).to eq 4
-  end
-
-  specify('#full_length') do
-    expect(RP.parse(/(aa)/)[0].full_length).to eq 4
-    expect(RP.parse(/(aa){42}/)[0].full_length).to eq 8
-  end
-end

data/spec/expression/clone_spec.rb

@@ -1,152 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe('Expression#clone') do
-  specify('Base#clone') do
-    root = RP.parse(/^(?i:a)b+$/i)
-    copy = root.clone
-
-    expect(copy.to_s).to eq root.to_s
-
-    expect(root.object_id).not_to eq copy.object_id
-    expect(root.text).to eq copy.text
-    expect(root.text.object_id).not_to eq copy.text.object_id
-
-    root_1 = root[1]
-    copy_1 = copy[1]
-
-    expect(root_1.options).to eq copy_1.options
-    expect(root_1.options.object_id).not_to eq copy_1.options.object_id
-
-    root_2 = root[2]
-    copy_2 = copy[2]
-
-    expect(root_2).to be_quantified
-    expect(copy_2).to be_quantified
-    expect(root_2.quantifier.text).to eq copy_2.quantifier.text
-    expect(root_2.quantifier.text.object_id).not_to eq copy_2.quantifier.text.object_id
-    expect(root_2.quantifier.object_id).not_to eq copy_2.quantifier.object_id
-
-    # regression test
-    expect { root_2.clone }.not_to(change { root_2.quantifier.object_id })
-    expect { root_2.clone }.not_to(change { root_2.quantifier.text.object_id })
-  end
-
-  specify('Subexpression#clone') do
-    root = RP.parse(/^a(b([cde])f)g$/)
-    copy = root.clone
-
-    expect(copy.to_s).to eq root.to_s
-
-    expect(root).to respond_to(:expressions)
-    expect(copy).to respond_to(:expressions)
-    expect(root.expressions.object_id).not_to eq copy.expressions.object_id
-    copy.expressions.each_with_index do |exp, index|
-      expect(root[index].object_id).not_to eq exp.object_id
-    end
-    copy[2].each_with_index do |exp, index|
-      expect(root[2][index].object_id).not_to eq exp.object_id
-    end
-
-    # regression test
-    expect { root.clone }.not_to(change { root.expressions.object_id })
-  end
-
-  specify('Group::Named#clone') do
-    root = RP.parse('^(?<somename>a)+bc$')
-    copy = root.clone
-
-    expect(copy.to_s).to eq root.to_s
-
-    root_1 = root[1]
-    copy_1 = copy[1]
-
-    expect(root_1.name).to eq copy_1.name
-    expect(root_1.name.object_id).not_to eq copy_1.name.object_id
-    expect(root_1.text).to eq copy_1.text
-    expect(root_1.expressions.object_id).not_to eq copy_1.expressions.object_id
-    copy_1.expressions.each_with_index do |exp, index|
-      expect(root_1[index].object_id).not_to eq exp.object_id
-    end
-
-    # regression test
-    expect { root_1.clone }.not_to(change { root_1.name.object_id })
-  end
-
-  specify('Group::Options#clone') do
-    root = RP.parse('foo(?i)bar')
-    copy = root.clone
-
-    expect(copy.to_s).to eq root.to_s
-
-    root_1 = root[1]
-    copy_1 = copy[1]
-
-    expect(root_1.option_changes).to eq copy_1.option_changes
-    expect(root_1.option_changes.object_id).not_to eq copy_1.option_changes.object_id
-
-    # regression test
-    expect { root_1.clone }.not_to(change { root_1.option_changes.object_id })
-  end
-
-  specify('Backreference::Base#clone') do
-    root = RP.parse('(foo)\1')
-    copy = root.clone
-
-    expect(copy.to_s).to eq root.to_s
-
-    root_1 = root[1]
-    copy_1 = copy[1]
-
-    expect(root_1.referenced_expression.to_s).to eq copy_1.referenced_expression.to_s
-    expect(root_1.referenced_expression.object_id).not_to eq copy_1.referenced_expression.object_id
-
-    # regression test
-    expect { root_1.clone }.not_to(change { root_1.referenced_expression.object_id })
-  end
-
-  specify('Sequence#clone') do
-    root = RP.parse(/(a|b)/)
-    copy = root.clone
-
-    # regression test
-    expect(copy.to_s).to eq root.to_s
-
-    root_seq_op = root[0][0]
-    copy_seq_op = copy[0][0]
-    root_seq_1 = root[0][0][0]
-    copy_seq_1 = copy[0][0][0]
-
-    expect(root_seq_op.object_id).not_to eq copy_seq_op.object_id
-    expect(root_seq_1.object_id).not_to eq copy_seq_1.object_id
-    copy_seq_1.expressions.each_with_index do |exp, index|
-      expect(root_seq_1[index].object_id).not_to eq exp.object_id
-    end
-  end
-
-  describe('Base#unquantified_clone') do
-    it 'produces a clone' do
-      root = RP.parse(/^a(b([cde])f)g$/)
-      copy = root.unquantified_clone
-
-      expect(copy.to_s).to eq root.to_s
-
-      expect(copy.object_id).not_to eq root.object_id
-    end
-
-    it 'does not carry over the callee quantifier' do
-      expect(RP.parse(/a{3}/)[0]).to be_quantified
-      expect(RP.parse(/a{3}/)[0].unquantified_clone).not_to be_quantified
-
-      expect(RP.parse(/[a]{3}/)[0]).to be_quantified
-      expect(RP.parse(/[a]{3}/)[0].unquantified_clone).not_to be_quantified
-
-      expect(RP.parse(/(a|b){3}/)[0]).to be_quantified
-      expect(RP.parse(/(a|b){3}/)[0].unquantified_clone).not_to be_quantified
-    end
-
-    it 'keeps quantifiers of callee children' do
-      expect(RP.parse(/(a{3}){3}/)[0][0]).to be_quantified
-      expect(RP.parse(/(a{3}){3}/)[0].unquantified_clone[0]).to be_quantified
-    end
-  end
-end

data/spec/expression/conditional_spec.rb

@@ -1,89 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe(Regexp::Expression::Conditional) do
-  let(:root)   { RP.parse('^(a(b))(b(?(1)c|(?(2)d|(?(3)e|f)))g)$') }
-  let(:cond_1) { root[2][1] }
-  let(:cond_2) { root[2][1][2][0] }
-  let(:cond_3) { root[2][1][2][0][2][0] }
-
-  specify('root level') do
-    [
-      '^',
-      '(a(b))',
-      '(b(?(1)c|(?(2)d|(?(3)e|f)))g)',
-      '$'
-    ].each_with_index do |t, i|
-      expect(root[i].conditional_level).to eq 0
-      expect(root[i].to_s).to eq t
-    end
-
-    expect(root[2][0].to_s).to eq 'b'
-    expect(root[2][0].conditional_level).to eq 0
-  end
-
-  specify('level one') do
-    condition = cond_1.condition
-    branch_1 = cond_1.branches.first
-
-    expect(condition).to be_a Conditional::Condition
-    expect(condition.to_s).to eq '(1)'
-    expect(condition.conditional_level).to eq 1
-
-    expect(branch_1).to be_a Conditional::Branch
-    expect(branch_1.to_s).to eq 'c'
-    expect(branch_1.conditional_level).to eq 1
-
-    expect(branch_1.first.to_s).to eq 'c'
-    expect(branch_1.first.conditional_level).to eq 1
-  end
-
-  specify('level two') do
-    condition = cond_2.condition
-    branch_1 = cond_2.branches.first
-    branch_2 = cond_2.branches.last
-
-    expect(cond_2.to_s).to start_with '(?'
-    expect(cond_2.conditional_level).to eq 1
-
-    expect(condition).to be_a Conditional::Condition
-    expect(condition.to_s).to eq '(2)'
-    expect(condition.conditional_level).to eq 2
-
-    expect(branch_1).to be_a Conditional::Branch
-    expect(branch_1.to_s).to eq 'd'
-    expect(branch_1.conditional_level).to eq 2
-
-    expect(branch_1.first.to_s).to eq 'd'
-    expect(branch_1.first.conditional_level).to eq 2
-
-    expect(branch_2.first.to_s).to start_with '(?'
-    expect(branch_2.first.conditional_level).to eq 2
-  end
-
-  specify('level three') do
-    condition = cond_3.condition
-    branch_1 = cond_3.branches.first
-    branch_2 = cond_3.branches.last
-
-    expect(condition).to be_a Conditional::Condition
-    expect(condition.to_s).to eq '(3)'
-    expect(condition.conditional_level).to eq 3
-
-    expect(cond_3.to_s).to eq '(?(3)e|f)'
-    expect(cond_3.conditional_level).to eq 2
-
-    expect(branch_1).to be_a Conditional::Branch
-    expect(branch_1.to_s).to eq 'e'
-    expect(branch_1.conditional_level).to eq 3
-
-    expect(branch_1.first.to_s).to eq 'e'
-    expect(branch_1.first.conditional_level).to eq 3
-
-    expect(branch_2).to be_a Conditional::Branch
-    expect(branch_2.to_s).to eq 'f'
-    expect(branch_2.conditional_level).to eq 3
-
-    expect(branch_2.first.to_s).to eq 'f'
-    expect(branch_2.first.conditional_level).to eq 3
-  end
-end

data/spec/expression/free_space_spec.rb

@@ -1,27 +0,0 @@
-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(Regexp::Parser::Error)
-  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(Regexp::Parser::Error)
-  end
-end

data/spec/expression/methods/match_length_spec.rb

@@ -1,161 +0,0 @@
-require 'spec_helper'
-
-ML = Regexp::MatchLength
-
-RSpec.describe(Regexp::MatchLength) do
-  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 aware of limit option even if called without a block' do
-      result = ML.of(/a?/).each(limit: 1)
-      expect(result).to be_a(Enumerator)
-      expect(result.next).to eq 0
-      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

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