regexp_parser 1.4.0 → 1.7.1

data/test/expression/test_subexpression.rb

@@ -1,58 +0,0 @@
-require File.expand_path("../../helpers", __FILE__)
-
-class ExpressionSubexpression < Test::Unit::TestCase
-
-  def test_subexpression_ts_te
-    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]
-
-      assert_equal span[0], sequence.ts
-      assert_equal span[1], sequence.te
-    end
-  end
-
-  def test_subexpression_nesting_level
-    root = RP.parse(/a(b(c\d|[ef-g[h]]))/)
-
-    tests = {
-      'a'         => 1,
-      'b'         => 2,
-      '|'         => 3,
-      'c\d'       => 4, # first alternative
-      'c'         => 5,
-      '\d'        => 5,
-      '[ef-g[h]]' => 4, # second alternative
-      'e'         => 5,
-      '-'         => 5,
-      'f'         => 6,
-      'g'         => 6,
-      'h'         => 6,
-    }
-
-    root.each_expression do |exp|
-      next unless (expected_nesting_level = tests.delete(exp.text))
-      assert_equal exp.nesting_level, expected_nesting_level
-    end
-
-    assert tests.empty?
-  end
-
-  def test_subexpression_dig
-    root = RP.parse(/(((a)))/)
-
-    assert_equal '(((a)))', root.dig(0).to_s
-    assert_equal 'a',       root.dig(0, 0, 0, 0).to_s
-    assert_nil              root.dig(0, 0, 0, 0, 0)
-    assert_nil              root.dig(3, 7)
-  end
-end

data/test/expression/test_tests.rb

@@ -1,99 +0,0 @@
-require File.expand_path("../../helpers", __FILE__)
-
-class ExpressionTests < Test::Unit::TestCase
-
-  def test_expression_type?
-    root = RP.parse(/abcd|(ghij)|[klmn]/)
-
-    alt = root.first
-
-    assert_equal true,  alt.type?(:meta)
-    assert_equal false, alt.type?(:escape)
-    assert_equal true,  alt.type?([:meta, :escape])
-    assert_equal false, alt.type?([:literal, :escape])
-    assert_equal true,  alt.type?(:*)
-    assert_equal true,  alt.type?([:*])
-    assert_equal true,  alt.type?([:literal, :escape, :*])
-
-    seq_1 = alt[0]
-    assert_equal true,  seq_1.type?(:expression)
-    assert_equal true,  seq_1.first.type?(:literal)
-
-    seq_2 = alt[1]
-    assert_equal true,  seq_2.type?(:*)
-    assert_equal true,  seq_2.first.type?(:group)
-
-    seq_3 = alt[2]
-    assert_equal true,  seq_3.first.type?(:set)
-  end
-
-  def test_expression_is?
-    root = RP.parse(/.+|\.?/)
-
-    assert_equal true,  root.is?(:*)
-
-    alt = root.first
-    assert_equal true,  alt.is?(:*)
-    assert_equal true,  alt.is?(:alternation)
-    assert_equal true,  alt.is?(:alternation, :meta)
-
-    seq_1 = alt[0]
-    assert_equal true,  seq_1.is?(:sequence)
-    assert_equal true,  seq_1.is?(:sequence, :expression)
-
-    assert_equal true,  seq_1.first.is?(:dot)
-    assert_equal false, seq_1.first.is?(:dot, :escape)
-    assert_equal true,  seq_1.first.is?(:dot, :meta)
-    assert_equal true,  seq_1.first.is?(:dot, [:escape, :meta])
-
-    seq_2 = alt[1]
-    assert_equal true,  seq_2.first.is?(:dot)
-    assert_equal true,  seq_2.first.is?(:dot, :escape)
-    assert_equal false, seq_2.first.is?(:dot, :meta)
-    assert_equal true,  seq_2.first.is?(:dot, [:meta, :escape])
-  end
-
-  def test_expression_one_of?
-    root = RP.parse(/\Aab(c[\w])d|e.\z/)
-
-    assert_equal true,  root.one_of?(:*)
-    assert_equal true,  root.one_of?(:* => :*)
-    assert_equal true,  root.one_of?(:* => [:*])
-
-    alt = root.first
-    assert_equal true,  alt.one_of?(:*)
-    assert_equal true,  alt.one_of?(:meta)
-    assert_equal true,  alt.one_of?(:meta, :alternation)
-    assert_equal false, alt.one_of?(:meta => [:dot, :bogus])
-    assert_equal true,  alt.one_of?(:meta => [:dot, :alternation])
-
-    seq_1 = alt[0]
-    assert_equal true,  seq_1.one_of?(:expression)
-    assert_equal true,  seq_1.one_of?(:expression => :sequence)
-
-    assert_equal true,  seq_1.first.one_of?(:anchor)
-    assert_equal true,  seq_1.first.one_of?(:anchor => :bos)
-    assert_equal false, seq_1.first.one_of?(:anchor => :eos)
-    assert_equal true,  seq_1.first.one_of?(:anchor => [:escape, :meta, :bos])
-    assert_equal false, seq_1.first.one_of?(:anchor => [:escape, :meta, :eos])
-
-    seq_2 = alt[1]
-    assert_equal true,  seq_2.first.one_of?(:literal)
-
-    assert_equal true,  seq_2[1].one_of?(:meta)
-    assert_equal true,  seq_2[1].one_of?(:meta => :dot)
-    assert_equal false, seq_2[1].one_of?(:meta => :alternation)
-    assert_equal true,  seq_2[1].one_of?(:meta => [:dot])
-
-    assert_equal false, seq_2.last.one_of?(:group)
-    assert_equal false, seq_2.last.one_of?(:group => [:*])
-    assert_equal false, seq_2.last.one_of?(:group => [:*], :meta => :*)
-
-    assert_equal true,  seq_2.last.one_of?(:meta => [:*], :* => :*)
-    assert_equal true,  seq_2.last.one_of?(:meta => [:*], :anchor => :*)
-    assert_equal true,  seq_2.last.one_of?(:meta => [:*], :anchor => :eos)
-    assert_equal false, seq_2.last.one_of?(:meta => [:*], :anchor => [:bos])
-    assert_equal true,  seq_2.last.one_of?(:meta => [:*], :anchor => [:bos, :eos])
-  end
-
-end

data/test/expression/test_to_h.rb

@@ -1,59 +0,0 @@
-require File.expand_path("../../helpers", __FILE__)
-
-class ExpressionToH < Test::Unit::TestCase
-
-  def test_expression_to_h
-    root = RP.parse('abc')
-
-    hash = root.to_h
-
-    assert_equal hash, {
-      :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
-        }
-      ]
-    }
-  end
-
-  def test_expression_quantifier_to_h
-    root = RP.parse('a{2,4}')
-    exp  = root.expressions.at(0)
-
-    hash = exp.quantifier.to_h
-
-    assert_equal hash, {
-      :max   => 4,
-      :min   => 2,
-      :mode  => :greedy,
-      :text  => '{2,4}',
-      :token => :interval
-    }
-  end
-
-  # regression test
-  def test_conditional_expression_to_h
-    root = RP.parse('(?<A>a)(?(<A>)b|c)', 'ruby/2.0')
-
-    assert_nothing_raised { root.to_h }
-  end
-end

data/test/expression/test_to_s.rb

@@ -1,104 +0,0 @@
-require File.expand_path("../../helpers", __FILE__)
-
-class ExpressionToS < Test::Unit::TestCase
-
-  def test_expression_to_s_literal_alternation
-    pattern = 'abcd|ghij|klmn|pqur'
-
-    assert_equal pattern, RP.parse(pattern).to_s
-  end
-
-  def test_expression_to_s_quantified_alternations
-    pattern = '(?:a?[b]+(c){2}|d+[e]*(f)?)|(?:g+[h]?(i){2,3}|j*[k]{3,5}(l)?)'
-
-    assert_equal pattern, RP.parse(pattern).to_s
-  end
-
-  def test_expression_to_s_quantified_sets
-    pattern = '[abc]+|[^def]{3,6}'
-
-    assert_equal pattern, RP.parse(pattern).to_s
-  end
-
-  def test_expression_to_s_property_sets
-    pattern = '[\a\b\p{Lu}\P{Z}\c\d]+'
-
-    assert_equal pattern, RP.parse(pattern, 'ruby/1.9').to_s
-  end
-
-  def test_expression_to_s_groups
-    pattern = "(a(?>b(?:c(?<n>d(?'N'e)??f)+g)*+h)*i)++"
-
-    assert_equal pattern, RP.parse(pattern, 'ruby/1.9').to_s
-  end
-
-  def test_expression_to_s_assertions
-    pattern = '(a+(?=b+(?!c+(?<=d+(?<!e+)?f+)?g+)?h+)?i+)?'
-
-    assert_equal pattern, RP.parse(pattern, 'ruby/1.9').to_s
-  end
-
-  def test_expression_to_s_comments
-    pattern = '(?#start)a(?#middle)b(?#end)'
-
-    assert_equal pattern, RP.parse(pattern).to_s
-  end
-
-  def test_expression_to_s_options
-    pattern = '(?mix:start)a(?-mix:middle)b(?i-mx:end)'
-
-    assert_equal pattern, RP.parse(pattern).to_s
-  end
-
-  def test_expression_to_s_url
-    pattern = '(^$)|(^(http|https):\/\/[a-z0-9]+([\-\.]{1}[a-z0-9]+)*'+
-              '\.[a-z]{2,5}(([0-9]{1,5})?\/.*)?$)'
-
-    assert_equal pattern, RP.parse(pattern).to_s
-  end
-
-  def test_expression_to_s_multiline_source
-    multiline = %r{
-      \A
-      a?      # One letter
-      b{2,5}  # Another one
-      [c-g]+  # A set
-      \z
-    }x
-
-    assert_equal multiline.source, RP.parse(multiline).to_s
-  end
-
-  def test_expression_to_s_multiline_to_s
-    multiline = %r{
-      \A
-      a?      # One letter
-      b{2,5}  # Another one
-      [c-g]+  # A set
-      \z
-    }x
-
-    assert_equal multiline.to_s, RP.parse(multiline.to_s).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.
-  def test_expression_to_s_multiline_equivalence
-    multiline = %r{
-      \A
-      a   ?             # One letter
-      b {2,5}           # Another one
-      [c-g]  +          # A set
-      \z
-    }x
-
-    str  = 'bbbcged'
-    root = RP.parse(multiline)
-
-    assert_equal multiline.match(str)[0],
-                 Regexp.new(root.to_s, Regexp::EXTENDED).match(str)[0]
-  end
-
-end

data/test/expression/test_traverse.rb

@@ -1,161 +0,0 @@
-require File.expand_path("../../helpers", __FILE__)
-
-class SubexpressionTraverse < Test::Unit::TestCase
-
-  def test_subexpression_traverse
-    root = RP.parse(/a(b(c(d)))|g[h-i]j|klmn/)
-
-    enters = 0
-    visits = 0
-    exits  = 0
-
-    root.traverse {|event, exp, index|
-      enters += 1 if event == :enter
-      visits += 1 if event == :visit
-      exits  += 1 if event == :exit
-    }
-
-    assert_equal 9,     enters
-    assert_equal exits, enters
-
-    assert_equal 9, visits
-  end
-
-  def test_subexpression_traverse_include_self
-    root = RP.parse(/a(b(c(d)))|g[h-i]j|klmn/)
-
-    enters = 0
-    visits = 0
-    exits  = 0
-
-    root.traverse(true) {|event, exp, index|
-      enters += 1 if event == :enter
-      visits += 1 if event == :visit
-      exits  += 1 if event == :exit
-    }
-
-    assert_equal 10,    enters
-    assert_equal exits, enters
-
-    assert_equal 9, visits
-  end
-
-  def test_subexpression_walk_alias
-    root = RP.parse(/abc/)
-
-    assert_equal true, root.respond_to?(:walk)
-  end
-
-  def test_subexpression_each_expression
-    root = RP.parse(/a(?x:b(c))|g[h-k]/)
-
-    count = 0
-    root.each_expression {|exp, index|
-      count += 1
-    }
-
-    assert_equal 13, count
-  end
-
-  def test_subexpression_each_expression_include_self
-    root = RP.parse(/a(?x:b(c))|g[h-k]/)
-
-    count = 0
-    root.each_expression(true) {|exp, index|
-      count += 1
-    }
-
-    assert_equal 14, count
-  end
-
-  def test_subexpression_each_expression_indices
-    root = RP.parse(/a(b)c/)
-
-    indices = []
-    root.each_expression {|exp, index| indices << index}
-
-    assert_equal [0, 1, 0, 2], indices
-  end
-
-  def test_subexpression_each_expression_indices_include_self
-    root = RP.parse(/a(b)c/)
-
-    indices = []
-    root.each_expression(true) {|exp, index| indices << index}
-
-    assert_equal [0, 0, 1, 0, 2], indices
-  end
-
-  def test_subexpression_flat_map_without_block
-    root = RP.parse(/a(b([c-e]+))?/)
-
-    array = root.flat_map
-
-    assert_equal Array, array.class
-    assert_equal 8, array.length
-
-    array.each do |item|
-      assert_equal Array, item.class
-      assert_equal 2,     item.length
-      assert_equal true,  item.first.is_a?(Regexp::Expression::Base)
-      assert_equal true,  item.last.is_a?(Integer)
-    end
-  end
-
-  def test_subexpression_flat_map_without_block_include_self
-    root = RP.parse(/a(b([c-e]+))?/)
-
-    array = root.flat_map(true)
-
-    assert_equal Array, array.class
-    assert_equal 9, array.length
-  end
-
-  def test_subexpression_flat_map_indices
-    root = RP.parse(/a(b([c-e]+))?f*g/)
-
-    indices = root.flat_map {|exp, index| index}
-
-    assert_equal [0, 1, 0, 1, 0, 0, 0, 1, 2, 3], indices
-  end
-
-  def test_subexpression_flat_map_indices_include_self
-    root = RP.parse(/a(b([c-e]+))?f*g/)
-
-    indices = root.flat_map(true) {|exp, index| index}
-
-    assert_equal [0, 0, 1, 0, 1, 0, 0, 0, 1, 2, 3], indices
-  end
-
-  def test_subexpression_flat_map_expressions
-    root = RP.parse(/a(b(c(d)))/)
-
-    levels = root.flat_map {|exp, index|
-      [exp.level, exp.text] if exp.terminal?
-    }.compact
-
-    assert_equal [
-        [0, 'a'], [1, 'b'], [2, 'c'], [3, 'd']
-      ], levels
-  end
-
-  def test_subexpression_flat_map_expressions_include_self
-    root = RP.parse(/a(b(c(d)))/)
-
-    levels = root.flat_map(true) {|exp, index|
-      [exp.level, exp.to_s]
-    }.compact
-
-    assert_equal [
-        [nil, 'a(b(c(d)))'],
-        [0,   'a'],
-        [0,   '(b(c(d)))'],
-        [1,   'b'],
-        [1,   '(c(d))'],
-        [2,   'c'],
-        [2,   '(d)'],
-        [3,   'd']
-      ], levels
-  end
-
-end