regexp_parser 1.3.0 → 1.6.0

data/spec/expression/methods/traverse_spec.rb

@@ -0,0 +1,140 @@
+require 'spec_helper'
+
+RSpec.describe('Subexpression#traverse') do
+  specify('Subexpression#traverse') do
+    root = RP.parse(/a(b(c(d)))|g[h-i]j|klmn/)
+
+    enters = 0
+    visits = 0
+    exits = 0
+
+    root.traverse do |event, _exp, _index|
+      enters = (enters + 1) if event == :enter
+      visits = (visits + 1) if event == :visit
+      exits = (exits + 1) if event == :exit
+    end
+
+    expect(enters).to eq 9
+    expect(enters).to eq exits
+
+    expect(visits).to eq 9
+  end
+
+  specify('Subexpression#traverse including self') do
+    root = RP.parse(/a(b(c(d)))|g[h-i]j|klmn/)
+
+    enters = 0
+    visits = 0
+    exits = 0
+
+    root.traverse(true) do |event, _exp, _index|
+      enters = (enters + 1) if event == :enter
+      visits = (visits + 1) if event == :visit
+      exits = (exits + 1) if event == :exit
+    end
+
+    expect(enters).to eq 10
+    expect(enters).to eq exits
+
+    expect(visits).to eq 9
+  end
+
+  specify('Subexpression#walk alias') do
+    root = RP.parse(/abc/)
+
+    expect(root).to respond_to(:walk)
+  end
+
+  specify('Subexpression#each_expression') do
+    root = RP.parse(/a(?x:b(c))|g[h-k]/)
+
+    count = 0
+    root.each_expression { count += 1 }
+
+    expect(count).to eq 13
+  end
+
+  specify('Subexpression#each_expression including self') do
+    root = RP.parse(/a(?x:b(c))|g[h-k]/)
+
+    count = 0
+    root.each_expression(true) { count += 1 }
+
+    expect(count).to eq 14
+  end
+
+  specify('Subexpression#each_expression indices') do
+    root = RP.parse(/a(b)c/)
+
+    indices = []
+    root.each_expression { |_exp, index| (indices << index) }
+
+    expect(indices).to eq [0, 1, 0, 2]
+  end
+
+  specify('Subexpression#each_expression indices including self') do
+    root = RP.parse(/a(b)c/)
+
+    indices = []
+    root.each_expression(true) { |_exp, index| (indices << index) }
+
+    expect(indices).to eq [0, 0, 1, 0, 2]
+  end
+
+  specify('Subexpression#flat_map without block') do
+    root = RP.parse(/a(b([c-e]+))?/)
+
+    array = root.flat_map
+
+    expect(array).to be_instance_of(Array)
+    expect(array.length).to eq 8
+
+    array.each do |item|
+      expect(item).to be_instance_of(Array)
+      expect(item.length).to eq 2
+      expect(item.first).to be_a(Regexp::Expression::Base)
+      expect(item.last).to be_a(Integer)
+    end
+  end
+
+  specify('Subexpression#flat_map without block including self') do
+    root = RP.parse(/a(b([c-e]+))?/)
+
+    array = root.flat_map(true)
+
+    expect(array).to be_instance_of(Array)
+    expect(array.length).to eq 9
+  end
+
+  specify('Subexpression#flat_map indices') do
+    root = RP.parse(/a(b([c-e]+))?f*g/)
+
+    indices = root.flat_map { |_exp, index| index }
+
+    expect(indices).to eq [0, 1, 0, 1, 0, 0, 0, 1, 2, 3]
+  end
+
+  specify('Subexpression#flat_map indices including self') do
+    root = RP.parse(/a(b([c-e]+))?f*g/)
+
+    indices = root.flat_map(true) { |_exp, index| index }
+
+    expect(indices).to eq [0, 0, 1, 0, 1, 0, 0, 0, 1, 2, 3]
+  end
+
+  specify('Subexpression#flat_map expressions') do
+    root = RP.parse(/a(b(c(d)))/)
+
+    levels = root.flat_map { |exp, _index| [exp.level, exp.text] if exp.terminal? }.compact
+
+    expect(levels).to eq [[0, 'a'], [1, 'b'], [2, 'c'], [3, 'd']]
+  end
+
+  specify('Subexpression#flat_map expressions including self') do
+    root = RP.parse(/a(b(c(d)))/)
+
+    levels = root.flat_map(true) { |exp, _index| [exp.level, exp.to_s] }.compact
+
+    expect(levels).to eq [[nil, 'a(b(c(d)))'], [0, 'a'], [0, '(b(c(d)))'], [1, 'b'], [1, '(c(d))'], [2, 'c'], [2, '(d)'], [3, 'd']]
+  end
+end

data/spec/expression/options_spec.rb

@@ -0,0 +1,128 @@
+require 'spec_helper'
+
+RSpec.describe('Expression#options') do
+  it 'returns a hash of options/flags that affect the expression' do
+    exp = RP.parse(/a/ix)[0]
+    expect(exp).to be_a Literal
+    expect(exp.options).to eq(i: true, x: true)
+  end
+
+  it 'includes options that are locally enabled via special groups' do
+    exp = RP.parse(/(?x)(?m:a)/i)[1][0]
+    expect(exp).to be_a Literal
+    expect(exp.options).to eq(i: true, m: true, x: true)
+  end
+
+  it 'excludes locally disabled options' do
+    exp = RP.parse(/(?x)(?-im:a)/i)[1][0]
+    expect(exp).to be_a Literal
+    expect(exp.options).to eq(x: true)
+  end
+
+  it 'gives correct precedence to negative options' do
+    # Negative options have precedence. E.g. /(?i-i)a/ is case-sensitive.
+    regexp = /(?i-i:a)/
+    expect(regexp).to match 'a'
+    expect(regexp).not_to match 'A'
+
+    exp = RP.parse(regexp)[0][0]
+    expect(exp).to be_a Literal
+    expect(exp.options).to eq({})
+  end
+
+  it 'correctly handles multiple negative option parts' do
+    regexp = /(?--m--mx--) . /mx
+    expect(regexp).to match ' . '
+    expect(regexp).not_to match '.'
+    expect(regexp).not_to match "\n"
+
+    exp = RP.parse(regexp)[2]
+    expect(exp.options).to eq({})
+  end
+
+  it 'gives correct precedence when encountering multiple encoding flags' do
+    # Any encoding flag overrides all previous encoding flags. If there are
+    # multiple encoding flags in an options string, the last one wins.
+    # E.g. /(?dau)\w/ matches UTF8 chars but /(?dua)\w/ only ASCII chars.
+    regexp1 = /(?dau)\w/
+    regexp2 = /(?dua)\w/
+    expect(regexp1).to match 'ü'
+    expect(regexp2).not_to match 'ü'
+
+    exp1 = RP.parse(regexp1)[1]
+    exp2 = RP.parse(regexp2)[1]
+    expect(exp1.options).to eq(u: true)
+    expect(exp2.options).to eq(a: true)
+  end
+
+  it 'is accessible via shortcuts' do
+    exp = Root.build
+
+    expect { exp.options[:i] = true }
+      .to  change { exp.i? }.from(false).to(true)
+      .and change { exp.ignore_case? }.from(false).to(true)
+      .and change { exp.case_insensitive? }.from(false).to(true)
+
+    expect { exp.options[:m] = true }
+      .to  change { exp.m? }.from(false).to(true)
+      .and change { exp.multiline? }.from(false).to(true)
+
+    expect { exp.options[:x] = true }
+      .to  change { exp.x? }.from(false).to(true)
+      .and change { exp.extended? }.from(false).to(true)
+      .and change { exp.free_spacing? }.from(false).to(true)
+
+    expect { exp.options[:a] = true }
+      .to  change { exp.a? }.from(false).to(true)
+      .and change { exp.ascii_classes? }.from(false).to(true)
+
+    expect { exp.options[:d] = true }
+      .to  change { exp.d? }.from(false).to(true)
+      .and change { exp.default_classes? }.from(false).to(true)
+
+    expect { exp.options[:u] = true }
+      .to  change { exp.u? }.from(false).to(true)
+      .and change { exp.unicode_classes? }.from(false).to(true)
+  end
+
+  RSpec.shared_examples '#options' do |regexp, klass, at: []|
+    it "works for expression class #{klass}" do
+      exp = RP.parse(/#{regexp.source}/i).dig(*at)
+      expect(exp).to be_a(klass)
+      expect(exp).to be_i
+      expect(exp).not_to be_x
+    end
+  end
+
+  include_examples '#options', //, Root
+  include_examples '#options', /a/, Literal, at: [0]
+  include_examples '#options', /\A/, Anchor::Base, at: [0]
+  include_examples '#options', /\d/, CharacterType::Base, at: [0]
+  include_examples '#options', /\n/, EscapeSequence::Base, at: [0]
+  include_examples '#options', /\K/, Keep::Mark, at: [0]
+  include_examples '#options', /./, CharacterType::Any, at: [0]
+  include_examples '#options', /(a)/, Group::Base, at: [0]
+  include_examples '#options', /(a)/, Literal, at: [0, 0]
+  include_examples '#options', /(?=a)/, Assertion::Base, at: [0]
+  include_examples '#options', /(?=a)/, Literal, at: [0, 0]
+  include_examples '#options', /(a|b)/, Group::Base, at: [0]
+  include_examples '#options', /(a|b)/, Alternation, at: [0, 0]
+  include_examples '#options', /(a|b)/, Alternative, at: [0, 0, 0]
+  include_examples '#options', /(a|b)/, Literal, at: [0, 0, 0, 0]
+  include_examples '#options', /(a)\1/, Backreference::Base, at: [1]
+  include_examples '#options', /(a)\k<1>/, Backreference::Number, at: [1]
+  include_examples '#options', /(a)\g<1>/, Backreference::NumberCall, at: [1]
+  include_examples '#options', /[a]/, CharacterSet, at: [0]
+  include_examples '#options', /[a]/, Literal, at: [0, 0]
+  include_examples '#options', /[a-z]/, CharacterSet::Range, at: [0, 0]
+  include_examples '#options', /[a-z]/, Literal, at: [0, 0, 0]
+  include_examples '#options', /[a&&z]/, CharacterSet::Intersection, at: [0, 0]
+  include_examples '#options', /[a&&z]/, CharacterSet::IntersectedSequence, at: [0, 0, 0]
+  include_examples '#options', /[a&&z]/, Literal, at: [0, 0, 0, 0]
+  include_examples '#options', /[[:ascii:]]/, PosixClass, at: [0, 0]
+  include_examples '#options', /\p{word}/, UnicodeProperty::Base, at: [0]
+  include_examples '#options', /(a)(?(1)b|c)/, Conditional::Expression, at: [1]
+  include_examples '#options', /(a)(?(1)b|c)/, Conditional::Condition, at: [1, 0]
+  include_examples '#options', /(a)(?(1)b|c)/, Conditional::Branch, at: [1, 1]
+  include_examples '#options', /(a)(?(1)b|c)/, Literal, at: [1, 1, 0]
+end

data/spec/expression/root_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+RSpec.describe(Regexp::Expression::Root) do
+  describe('#initialize') do
+    it 'supports the old, nonstandard arity for backwards compatibility' do
+      expect { Root.new }.to output.to_stderr
+    end
+  end
+end

data/spec/expression/sequence_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+RSpec.describe(Regexp::Expression::Sequence) do
+  describe('#initialize') do
+    it 'supports the old, nonstandard arity for backwards compatibility' do
+      expect { Sequence.new(0, 0, 0) }.to output.to_stderr
+    end
+  end
+end

data/spec/expression/subexpression_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+
+RSpec.describe(Regexp::Expression::Subexpression) do
+  specify('#ts, #te') do
+    regx = /abcd|ghij|klmn|pqur/
+    root = RP.parse(regx)
+
+    alt = root.first
+
+    { 0 => [0, 4], 1 => [5, 9], 2 => [10, 14], 3 => [15, 19] }.each do |index, span|
+      sequence = alt[index]
+
+      expect(sequence.ts).to eq span[0]
+      expect(sequence.te).to eq span[1]
+    end
+  end
+
+  specify('#nesting_level') do
+    root = RP.parse(/a(b(\d|[ef-g[h]]))/)
+
+    tests = {
+      'a'            => 1,
+      'b'            => 2,
+      '\d|[ef-g[h]]' => 3, # alternation
+      '\d'           => 4, # first alternative
+      '[ef-g[h]]'    => 4, # second alternative
+      'e'            => 5,
+      'f-g'          => 5,
+      'f'            => 6,
+      'g'            => 6,
+      'h'            => 6,
+    }
+
+    root.each_expression do |exp|
+      next unless expected_nesting_level = tests.delete(exp.to_s)
+      expect(expected_nesting_level).to eq exp.nesting_level
+    end
+
+    expect(tests).to be_empty
+  end
+
+  specify('#dig') do
+    root = RP.parse(/(((a)))/)
+
+    expect(root.dig(0).to_s).to eq '(((a)))'
+    expect(root.dig(0, 0, 0, 0).to_s).to eq 'a'
+    expect(root.dig(0, 0, 0, 0, 0)).to be_nil
+    expect(root.dig(3, 7)).to be_nil
+  end
+end

data/spec/expression/to_h_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+RSpec.describe('Expression#to_h') do
+  specify('Root#to_h') do
+    root = RP.parse('abc')
+
+    hash = root.to_h
+
+    expect(token: :root, type: :expression, text: 'abc', starts_at: 0, length: 3, quantifier: nil, options: {}, level: nil, set_level: nil, conditional_level: nil, expressions: [{ token: :literal, type: :literal, text: 'abc', starts_at: 0, length: 3, quantifier: nil, options: {}, level: 0, set_level: 0, conditional_level: 0 }]).to eq hash
+  end
+
+  specify('Quantifier#to_h') do
+    root = RP.parse('a{2,4}')
+    exp = root.expressions.at(0)
+
+    hash = exp.quantifier.to_h
+
+    expect(max: 4, min: 2, mode: :greedy, text: '{2,4}', token: :interval).to eq hash
+  end
+
+  specify('Conditional#to_h') do
+    root = RP.parse('(?<A>a)(?(<A>)b|c)', 'ruby/2.0')
+
+    expect { root.to_h }.not_to(raise_error)
+  end
+end

data/spec/expression/to_s_spec.rb

@@ -0,0 +1,100 @@
+require 'spec_helper'
+
+RSpec.describe('Expression#to_s') do
+  specify('literal alternation') do
+    pattern = 'abcd|ghij|klmn|pqur'
+
+    expect(RP.parse(pattern).to_s).to eq pattern
+  end
+
+  specify('quantified alternations') do
+    pattern = '(?:a?[b]+(c){2}|d+[e]*(f)?)|(?:g+[h]?(i){2,3}|j*[k]{3,5}(l)?)'
+
+    expect(RP.parse(pattern).to_s).to eq pattern
+  end
+
+  specify('quantified sets') do
+    pattern = '[abc]+|[^def]{3,6}'
+
+    expect(RP.parse(pattern).to_s).to eq pattern
+  end
+
+  specify('property sets') do
+    pattern = '[\\a\\b\\p{Lu}\\P{Z}\\c\\d]+'
+
+    expect(RP.parse(pattern, 'ruby/1.9').to_s).to eq pattern
+  end
+
+  specify('groups') do
+    pattern = "(a(?>b(?:c(?<n>d(?'N'e)??f)+g)*+h)*i)++"
+
+    expect(RP.parse(pattern, 'ruby/1.9').to_s).to eq pattern
+  end
+
+  specify('assertions') do
+    pattern = '(a+(?=b+(?!c+(?<=d+(?<!e+)?f+)?g+)?h+)?i+)?'
+
+    expect(RP.parse(pattern, 'ruby/1.9').to_s).to eq pattern
+  end
+
+  specify('comments') do
+    pattern = '(?#start)a(?#middle)b(?#end)'
+
+    expect(RP.parse(pattern).to_s).to eq pattern
+  end
+
+  specify('options') do
+    pattern = '(?mix:start)a(?-mix:middle)b(?i-mx:end)'
+
+    expect(RP.parse(pattern).to_s).to eq pattern
+  end
+
+  specify('url') do
+    pattern = ('(^$)|(^(http|https):\\/\\/[a-z0-9]+([\\-\\.]{1}[a-z0-9]+)*' + '\\.[a-z]{2,5}(([0-9]{1,5})?\\/.*)?$)')
+
+    expect(RP.parse(pattern).to_s).to eq pattern
+  end
+
+  specify('multiline source') do
+    multiline = /
+          \A
+          a?      # One letter
+          b{2,5}  # Another one
+          [c-g]+  # A set
+          \z
+        /x
+
+    expect(RP.parse(multiline).to_s).to eq multiline.source
+  end
+
+  specify('multiline #to_s') do
+    multiline = /
+          \A
+          a?      # One letter
+          b{2,5}  # Another one
+          [c-g]+  # A set
+          \z
+        /x
+
+    expect(RP.parse(multiline.to_s).to_s).to eq multiline.to_s
+  end
+
+  # Free spacing expressions that use spaces between quantifiers and their
+  # targets do not produce identical results due to the way quantifiers are
+  # applied to expressions (members, not nodes) and the merging of consecutive
+  # space nodes. This tests that they produce equivalent results.
+  specify('multiline equivalence') do
+    multiline = /
+          \A
+          a   ?             # One letter
+          b {2,5}           # Another one
+          [c-g]  +          # A set
+          \z
+        /x
+
+    str = 'bbbcged'
+    root = RP.parse(multiline)
+
+    expect(Regexp.new(root.to_s, Regexp::EXTENDED).match(str)[0]).to eq multiline.match(str)[0]
+  end
+end