regexp_parser 1.4.0 → 1.5.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/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

data/spec/lexer/all_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+RSpec.describe(Regexp::Lexer) do
+  specify('lexer returns an array') do
+    expect(RL.lex('abc')).to be_instance_of(Array)
+  end
+
+  specify('lexer returns tokens') do
+    tokens = RL.lex('^abc+[^one]{2,3}\\b\\d\\\\C-C$')
+    expect(tokens).to all(be_a Regexp::Token)
+    expect(tokens.map { |token| token.to_a.length }).to all(eq 8)
+  end
+
+  specify('lexer token count') do
+    tokens = RL.lex(/^(one|two){2,3}([^d\]efm-qz\,\-]*)(ghi)+$/i)
+    expect(tokens.length).to eq 28
+  end
+
+  specify('lexer scan alias') do
+    expect(RL.scan(/a|b|c/)).to eq RL.lex(/a|b|c/)
+  end
+end

data/{test/lexer/test_conditionals.rb → spec/lexer/conditionals_spec.rb}

@@ -1,8 +1,6 @@
-require File.expand_path("../../helpers", __FILE__)
-
-class LexerConditionals < Test::Unit::TestCase
-  if RUBY_VERSION >= '2.0'
+require 'spec_helper'
 
+RSpec.describe('Conditional lexing') do
   # Basic lexer output and nesting tests
   tests = {
     '(?<A>a)(?(<A>)b|c)'  => [3, :conditional, :open,       '(?',     7,  9, 0, 0, 0],
@@ -12,23 +10,23 @@ class LexerConditionals < Test::Unit::TestCase
   }
 
   tests.each_with_index do |(pattern, (index, type, token, text, ts, te, level, set_level, conditional_level)), count|
-    define_method "test_lexer_#{type}_#{token}_#{count}" do
+    specify("lexer_#{type}_#{token}_#{count}") do
       tokens = RL.lex(pattern)
       struct = tokens.at(index)
 
-      assert_equal type,              struct.type
-      assert_equal token,             struct.token
-      assert_equal text,              struct.text
-      assert_equal ts,                struct.ts
-      assert_equal te,                struct.te
-      assert_equal level,             struct.level
-      assert_equal set_level,         struct.set_level
-      assert_equal conditional_level, struct.conditional_level
+      expect(struct.type).to eq type
+      expect(struct.token).to eq token
+      expect(struct.text).to eq text
+      expect(struct.ts).to eq ts
+      expect(struct.te).to eq te
+      expect(struct.level).to eq level
+      expect(struct.set_level).to eq set_level
+      expect(struct.conditional_level).to eq conditional_level
     end
   end
 
-  def test_lexer_conditional_mixed_nesting
-    regexp = /((?<A>a)(?<B>(?(<A>)b|((?(<B>)[e-g]|[h-j])))))/
+  specify('lexer conditional mixed nesting') do
+    regexp = '((?<A>a)(?<B>(?(<A>)b|((?(<B>)[e-g]|[h-j])))))'
     tokens = RL.lex(regexp)
 
     [
@@ -57,19 +55,19 @@ class LexerConditionals < Test::Unit::TestCase
     ].each do |index, type, token, text, ts, te, level, set_level, conditional_level|
       struct = tokens.at(index)
 
-      assert_equal type,              struct.type
-      assert_equal token,             struct.token
-      assert_equal text,              struct.text
-      assert_equal ts,                struct.ts
-      assert_equal te,                struct.te
-      assert_equal level,             struct.level
-      assert_equal set_level,         struct.set_level
-      assert_equal conditional_level, struct.conditional_level
+      expect(struct.type).to eq type
+      expect(struct.token).to eq token
+      expect(struct.text).to eq text
+      expect(struct.ts).to eq ts
+      expect(struct.te).to eq te
+      expect(struct.level).to eq level
+      expect(struct.set_level).to eq set_level
+      expect(struct.conditional_level).to eq conditional_level
     end
   end
 
-  def test_lexer_conditional_deep_nesting
-    regexp = /(a(b(c)))(?(1)(?(2)(?(3)d|e))|(?(3)(?(2)f|g)|(?(1)f|g)))/
+  specify('lexer conditional deep nesting') do
+    regexp = '(a(b(c)))(?(1)(?(2)(?(3)d|e))|(?(3)(?(2)f|g)|(?(1)f|g)))'
     tokens = RL.lex(regexp)
 
     [
@@ -112,16 +110,14 @@ class LexerConditionals < Test::Unit::TestCase
     ].each do |index, type, token, text, ts, te, level, set_level, conditional_level|
       struct = tokens.at(index)
 
-      assert_equal type,              struct.type
-      assert_equal token,             struct.token
-      assert_equal text,              struct.text
-      assert_equal ts,                struct.ts
-      assert_equal te,                struct.te
-      assert_equal level,             struct.level
-      assert_equal set_level,         struct.set_level
-      assert_equal conditional_level, struct.conditional_level
+      expect(struct.type).to eq type
+      expect(struct.token).to eq token
+      expect(struct.text).to eq text
+      expect(struct.ts).to eq ts
+      expect(struct.te).to eq te
+      expect(struct.level).to eq level
+      expect(struct.set_level).to eq set_level
+      expect(struct.conditional_level).to eq conditional_level
     end
   end
-
-  end # if RUBY_VERSION >= '2.0'
 end

data/spec/lexer/escapes_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+RSpec.describe('Escape lexing') do
+  tests = {
+    '\u{62}' => {
+      0     => [:escape,     :codepoint_list,   '\u{62}',        0, 6,   0, 0, 0],
+    },
+
+    '\u{62 63 64}' => {
+      0     => [:escape,     :codepoint_list,   '\u{62 63 64}',  0, 12,  0, 0, 0],
+    },
+
+    '\u{62 63 64}+' => {
+      0     => [:escape,     :codepoint_list,   '\u{62 63}',     0,  9,  0, 0, 0],
+      1     => [:escape,     :codepoint_list,   '\u{64}',        9,  15, 0, 0, 0],
+      2     => [:quantifier, :one_or_more,      '+',             15, 16, 0, 0, 0],
+    },
+  }
+
+  tests.each_with_index do |(pattern, checks), count|
+    specify("lex_escape_runs_#{count}") do
+      tokens = RL.lex(pattern)
+
+      checks.each do |index, (type, token, text, ts, te, level, set_level, conditional_level)|
+        struct = tokens.at(index)
+
+        expect(struct.type).to eq type
+        expect(struct.token).to eq token
+        expect(struct.text).to eq text
+        expect(struct.ts).to eq ts
+        expect(struct.te).to eq te
+        expect(struct.level).to eq level
+        expect(struct.set_level).to eq set_level
+        expect(struct.conditional_level).to eq conditional_level
+      end
+    end
+  end
+end