regexp_parser 0.1.1 → 0.1.5

data/test/expression/test_all.rb

@@ -0,0 +1,7 @@
+require File.expand_path("../../helpers", __FILE__)
+
+%w{
+  base to_s clone
+}.each do|tc|
+  require File.expand_path("../test_#{tc}", __FILE__)
+end

data/test/expression/test_base.rb

@@ -0,0 +1,72 @@
+require File.expand_path("../../helpers", __FILE__)
+
+class ExpressionBase < Test::Unit::TestCase
+
+  def test_expression_to_re
+    re_text = '^a*(b([cde]+))+f?$'
+
+    re = RP.parse(re_text).to_re
+
+    assert( re.is_a?(::Regexp),
+          'Not a Regexp, but should be')
+
+    assert_equal( re.source, re_text )
+  end
+
+  def test_expression_terminal?
+    root = RP.parse('^a([b]+)c$')
+
+    assert_equal( false, root.terminal? )
+
+    assert_equal( true,  root[0].terminal? )
+    assert_equal( true,  root[1].terminal? )
+    assert_equal( false, root[2].terminal? )
+    assert_equal( true,  root[2][0].terminal? )
+    assert_equal( true,  root[3].terminal? )
+    assert_equal( true,  root[4].terminal? )
+  end
+
+  def test_expression_alt_terminal?
+    root = RP.parse('^(ab|cd)$')
+
+    assert_equal( false, root.terminal? )
+
+    assert_equal( true,  root[0].terminal? )
+    assert_equal( false, root[1].terminal? )
+    assert_equal( false,  root[1][0].terminal? )
+    assert_equal( false, root[1][0][0].terminal? )
+    assert_equal( true,  root[1][0][0][0].terminal? )
+    assert_equal( false, root[1][0][1].terminal? )
+    assert_equal( true,  root[1][0][1][0].terminal? )
+  end
+
+  def test_expression_coded_offset
+    root = RP.parse('^a*(b+(c?))$')
+
+    assert_equal( '@0+12', root.coded_offset )
+
+    # All top level offsets
+    checks = [
+      [ '@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 ]
+      assert_equal( check, against )
+    end
+
+    # Nested expression
+    assert_equal(['@4+2', 'b+'],
+      [root[2][0].coded_offset, root[2][0].to_s])
+
+    # Nested subexpression
+    assert_equal(['@6+4', '(c?)'],
+      [root[2][1].coded_offset, root[2][1].to_s])
+
+    # Nested subexpression expression
+    assert_equal(['@7+2', 'c?'],
+      [root[2][1][0].coded_offset, root[2][1][0].to_s])
+  end
+
+end

data/test/expression/test_clone.rb

@@ -0,0 +1,144 @@
+require File.expand_path("../../helpers", __FILE__)
+
+class ExpressionClone < Test::Unit::TestCase
+
+  def test_expression_clone_base
+    root = RP.parse(/^(?i:a)b+$/i)
+    copy = root.clone
+
+    assert_not_equal(copy.object_id, root.object_id)
+
+    # The text content is equal but the objects are not.
+    assert_equal(copy.text, root.text)
+    assert_not_equal(copy.text.object_id, root.text.object_id)
+
+    root_1 = root.expressions[1]
+    copy_1 = copy.expressions[1]
+
+    # The options hash contents are equal but the objects are not.
+    assert_equal(copy_1.options, root_1.options)
+    assert_not_equal(copy_1.options.object_id,
+                     root_1.options.object_id)
+
+    root_2 = root.expressions[2]
+    copy_2 = copy.expressions[2]
+
+    assert( root_2.quantified? )
+    assert( copy_2.quantified? )
+
+    # The quantifier contents are equal but the objects are not.
+    assert_equal(copy_2.quantifier.text, root_2.quantifier.text)
+
+    assert_not_equal(copy_2.quantifier.text.object_id,
+                     root_2.quantifier.text.object_id)
+
+    assert_not_equal(copy_2.quantifier.object_id,
+                     root_2.quantifier.object_id)
+  end
+
+  def test_expression_clone_subexpression
+    root = RP.parse(/^a(b([cde])f)g$/)
+    copy = root.clone
+
+    assert( root.respond_to?(:expressions) )
+    assert( copy.respond_to?(:expressions) )
+
+    # The expressions arrays are not equal.
+    assert_not_equal(copy.expressions.object_id,
+                     root.expressions.object_id)
+
+    # The expressions in the arrays are not equal.
+    copy.expressions.each_with_index do |e, ei|
+      assert_not_equal(e.object_id,
+                       root.expressions[ei].object_id)
+    end
+
+    # The expressions in nested expressions are not equal.
+    copy.expressions[2].each_with_index do |e, ei|
+      assert_not_equal(e.object_id,
+                       root.expressions[2][ei].object_id)
+    end
+  end
+
+  # ruby 1.8 does not implement named groups
+  def test_expression_clone_named_group
+    root = RP.parse('^(?<somename>a)+bc$')
+    copy = root.clone
+
+    root_1 = root.expressions[1]
+    copy_1 = copy.expressions[1]
+
+    # The names are equal but their objects are not.
+    assert_equal(copy_1.name, root_1.name)
+    assert_not_equal(copy_1.name.object_id,
+                     root_1.name.object_id)
+
+    # Verify super: text objects should be different.
+    assert_equal(copy_1.text, root_1.text)
+
+    # Verify super: expressions arrays are not equal.
+    assert_not_equal(copy_1.expressions.object_id,
+                     root_1.expressions.object_id)
+
+    # Verify super: expressions in the arrays are not equal.
+    copy_1.expressions.each_with_index do |e, ei|
+      assert_not_equal(e.object_id,
+                       root_1.expressions[ei].object_id)
+    end
+  end
+
+  def test_expression_clone_set
+    root = RP.parse(/^a(b([cde])f)g$/)
+    copy = root.clone
+
+    root_2_1 = root.expressions[2][1]
+
+    copy.expressions[2][1].each_with_index do |e, ei|
+      assert( e.respond_to?(:members) )
+
+      # The members arrays are not equal.
+      assert_not_equal( e.members.object_id, root_2_1[ei].members.object_id )
+
+      # The members in the arrays are not equal.
+      e.members.each_with_index do |m, mi|
+        assert_not_equal( m.object_id, root_2_1[ei].members[mi].object_id )
+      end
+    end
+  end
+
+  def test_expression_clone_subset
+    # Explicitly set syntax to ruby 1.9 because 1.8 does not
+    # implement subsets.
+    root = RP.parse('^a(b([c[def]g])h)i$', 'ruby/1.9')
+    copy = root.clone
+
+    root_set    = root.expressions[2][1][0]
+    copy_set    = copy.expressions[2][1][0]
+
+    root_subset = root_set.members[1]
+    copy_subset = copy_set.members[1]
+
+    # Sanity checks
+    assert( root_set.respond_to?(:members) )
+    assert( copy_set.respond_to?(:members) )
+
+    assert( root_subset.respond_to?(:members) )
+    assert( copy_subset.respond_to?(:members) )
+
+    # The sets are not equal
+    assert_not_equal(copy_set.object_id, root_set.object_id)
+
+    # The subsets are not equal
+    assert_not_equal(copy_subset.object_id, root_subset.object_id)
+
+    # The subsets' members arrays are not equal.
+    assert_not_equal( copy_subset.members.object_id,
+                      root_subset.members.object_id )
+
+    # The subsets' members are not equal
+    copy_subset.members.each_with_index do |m, mi|
+      assert_not_equal(m.object_id, root_subset.members[mi].object_id)
+    end
+  end
+
+end

data/test/{parser/test_expression.rb → expression/test_to_s.rb}

@@ -1,48 +1,48 @@
 require File.expand_path("../../helpers", __FILE__)
 
-class ParserExpression < Test::Unit::TestCase
+class ExpressionToS < Test::Unit::TestCase
 
-  def test_parse_expression_to_s_literal_alternation
+  def test_expression_to_s_literal_alternation
     pattern = 'abcd|ghij|klmn|pqur'
     assert_equal( pattern, RP.parse(pattern).to_s )
   end
 
-  def test_parse_expression_to_s_quantified_alternations
+  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_parse_expression_to_s_quantified_sets
+  def test_expression_to_s_quantified_sets
     pattern = '[abc]+|[^def]{3,6}'
     assert_equal( pattern, RP.parse(pattern).to_s )
   end
 
-  def test_parse_expression_to_s_property_sets
+  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_parse_expression_to_s_groups
+  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_parse_expression_to_s_assertions
+  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_parse_expression_to_s_comments
+  def test_expression_to_s_comments
     pattern = '(?#start)a(?#middle)b(?#end)'
     assert_equal( pattern, RP.parse(pattern).to_s )
   end
 
-  def test_parse_expression_to_s_options
+  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_parse_expression_to_s_url
+  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 )

data/test/helpers.rb

@@ -4,5 +4,6 @@ require File.expand_path("../../lib/regexp_parser", __FILE__)
 RS = Regexp::Scanner
 RL = Regexp::Lexer
 RP = Regexp::Parser
+RE = Regexp::Expression
 
 include Regexp::Expression

data/test/parser/test_all.rb

@@ -1,7 +1,7 @@
 require File.expand_path("../../helpers", __FILE__)
 
 %w{
-  alternation anchors errors escapes expression groups properties
+  alternation anchors errors escapes groups properties
   quantifiers refcalls sets
 }.each do|tc|
   require File.expand_path("../test_#{tc}", __FILE__)

data/test/parser/test_alternation.rb

@@ -43,4 +43,39 @@ class ParserAlternation < Test::Unit::TestCase
     assert_equal( 2,      nested.expressions.length )
   end
 
+  def test_parse_alternation_nested_groups
+    root = RP.parse('(i|ey|([ougfd]+)|(ney))')
+
+    alts = root.expressions[0][0].alternatives
+    assert_equal( 4,  alts.length )
+  end
+
+  def test_parse_alternation_grouped_alts
+    root = RP.parse('ca((n)|(t)|(ll)|(b))')
+
+    alts = root.expressions[1][0].alternatives
+
+    assert_equal( 4,  alts.length )
+    assert_equal( true,   alts[0].is_a?(Sequence) )
+    assert_equal( true,   alts[1].is_a?(Sequence) )
+    assert_equal( true,   alts[2].is_a?(Sequence) )
+    assert_equal( true,   alts[3].is_a?(Sequence) )
+  end
+
+  def test_parse_alternation_nested_grouped_alts
+    root = RP.parse('ca((n|t)|(ll|b))')
+
+    alts = root.expressions[1][0].alternatives
+
+    assert_equal( 2,  alts.length )
+    assert_equal( true,   alts[0].is_a?(Sequence) )
+    assert_equal( true,   alts[1].is_a?(Sequence) )
+
+    subalts = root.expressions[1][0][0][0][0].alternatives
+
+    assert_equal( 2,  alts.length )
+    assert_equal( true,   subalts[0].is_a?(Sequence) )
+    assert_equal( true,   subalts[1].is_a?(Sequence) )
+  end
+
 end

data/test/parser/test_anchors.rb

@@ -3,8 +3,8 @@ require File.expand_path("../../helpers", __FILE__)
 class TestParserAnchors < Test::Unit::TestCase
 
   tests = {
-    '^a'      => [0, :anchor,   :beginning_of_line,   Anchor::BOL],
-    'a$'      => [1, :anchor,   :end_of_line,         Anchor::EOL],
+    '^a'      => [0, :anchor,   :bol,                 Anchor::BOL],
+    'a$'      => [1, :anchor,   :eol,                 Anchor::EOL],
 
     '\Aa'     => [0, :anchor,   :bos,                 Anchor::BOS],
     'a\z'     => [1, :anchor,   :eos,                 Anchor::EOS],

data/test/parser/test_refcalls.rb

@@ -1,6 +1,6 @@
 require File.expand_path("../../helpers", __FILE__)
 
-class TestParserGroups < Test::Unit::TestCase
+class TestParserRefcalls < Test::Unit::TestCase
 
   def test_parse_backref_named_ab
     t = RP.parse('(?<X>abc)\k<X>', 'ruby/1.9')[1]

data/test/parser/test_sets.rb

@@ -23,10 +23,8 @@ class TestParserSets < Test::Unit::TestCase
 
     assert_equal( true,  exp.matches?("6") )
 
-    # TODO: figure out why this generate wrong string, but only after
-    # the assertion above (to_s "piles up")
-    #assert_equal( true,  exp.matches?("v") )
-    #assert_equal( false, exp.matches?("\x48") )
+    assert_equal( true,  exp.matches?("v") )
+    assert_equal( false, exp.matches?("\x48") )
   end
 
   def test_parse_set_members
@@ -67,16 +65,64 @@ class TestParserSets < Test::Unit::TestCase
     assert_equal( true, exp.include?('c') )
   end
 
+  def test_parse_set_nesting_include_at_depth
+    exp = RP.parse('[a[b]c]', 'ruby/1.9')[0]
+
+    assert_equal( true,  exp.is_a?(CharacterSet) )
+    assert_equal( true,  exp.include?('a') )
+    assert_equal( true,  exp.include?('b') )
+    assert_equal( false, exp.include?('b', true) ) # should not include b directly
+
+    sub = exp.members[1]
+    assert_equal( false, sub.include?('a') )
+    assert_equal( true,  sub.include?('b') )
+    assert_equal( true,  sub.include?('b', true) )
+    assert_equal( false, sub.include?('c') )
+  end
+
+  def test_parse_set_nesting_include_at_depth_2
+    exp = RP.parse('[a[b[c[d]e]f]g]', 'ruby/1.9')[0]
+
+    assert_equal( true,  exp.is_a?(CharacterSet) )
+    assert_equal( true,  exp.include?('a') )
+    assert_equal( true,  exp.include?('b') )
+    assert_equal( false, exp.include?('b', true) ) # should not include b directly
+
+    sub = exp.members[1]
+    assert_equal( false, sub.include?('a') )
+    assert_equal( true,  sub.include?('b') )
+    assert_equal( true,  sub.include?('b', true) )
+    assert_equal( true,  sub.include?('f', true) )
+    assert_equal( true,  sub.include?('c') )
+    assert_equal( false, sub.include?('c', true) )
+
+    sub2 = sub.members[1]
+    assert_equal( false, sub2.include?('a') )
+    assert_equal( false, sub2.include?('b') )
+    assert_equal( true,  sub2.include?('c') )
+    assert_equal( true,  sub2.include?('c', true) )
+    assert_equal( true,  sub2.include?('e', true) )
+    assert_equal( true,  sub2.include?('d') )
+    assert_equal( false, sub2.include?('d', true) )
+
+    sub3 = sub2.members[1]
+    assert_equal( false, sub3.include?('a') )
+    assert_equal( false, sub3.include?('g') )
+    assert_equal( false, sub3.include?('b') )
+    assert_equal( false, sub3.include?('f') )
+    assert_equal( false, sub3.include?('c') )
+    assert_equal( false, sub3.include?('e') )
+    assert_equal( true,  sub3.include?('d') )
+    assert_equal( true,  sub3.include?('d', true) )
+  end
+
   # character subsets and negated posix classes are not available in ruby 1.8
   if RUBY_VERSION >= '1.9'
     def test_parse_set_nesting_matches
       exp = RP.parse('[a[b[^c]]]', 'ruby/1.9')[0]
 
       assert_equal( true,  exp.matches?("b") )
-
-      # TODO: figure out why this generate wrong string, but only after
-      # the assertion above (to_s "piles up")
-      #assert_equal( false, exp.matches?("c") )
+      assert_equal( false, exp.matches?("c") )
     end
 
     def test_parse_set_nesting_not_matches