regexp_parser 0.3.4 → 0.3.5

data/test/parser/test_refcalls.rb

@@ -3,99 +3,115 @@ require File.expand_path("../../helpers", __FILE__)
 class TestParserRefcalls < Test::Unit::TestCase
 
   def test_parse_backref_named_ab
-    t = RP.parse('(?<X>abc)\k<X>', 'ruby/1.9')[1]
+    root = RP.parse('(?<X>abc)\k<X>', 'ruby/1.9')
+    exp  = root.expressions.at(1)
 
-    assert_equal( true,  t.is_a?(Backreference::Name) )
+    assert_equal true, exp.is_a?(Backreference::Name)
   end
 
   def test_parse_backref_named_sq
-    t = RP.parse("(?<X>abc)\\k'X'", 'ruby/1.9')[1]
+    root = RP.parse("(?<X>abc)\\k'X'", 'ruby/1.9')
+    exp  = root.expressions.at(1)
 
-    assert_equal( true,  t.is_a?(Backreference::Name) )
+    assert_equal true, exp.is_a?(Backreference::Name)
   end
 
   def test_parse_backref_number_ab
-    t = RP.parse('(abc)\k<1>', 'ruby/1.9')[1]
+    root = RP.parse('(abc)\k<1>', 'ruby/1.9')
+    exp  = root.expressions.at(1)
 
-    assert_equal( true,  t.is_a?(Backreference::Number) )
+    assert_equal true, exp.is_a?(Backreference::Number)
   end
 
   def test_parse_backref_number_sq
-    t = RP.parse("(abc)\\k'1'", 'ruby/1.9')[1]
+    root = RP.parse("(abc)\\k'1'", 'ruby/1.9')
+    exp  = root.expressions.at(1)
 
-    assert_equal( true,  t.is_a?(Backreference::Number) )
+    assert_equal true, exp.is_a?(Backreference::Number)
   end
 
   def test_parse_backref_number_relative_ab
-    t = RP.parse('(abc)\k<-1>', 'ruby/1.9')[1]
+    root = RP.parse('(abc)\k<-1>', 'ruby/1.9')
+    exp  = root.expressions.at(1)
 
-    assert_equal( true,  t.is_a?(Backreference::NumberRelative) )
+    assert_equal true, exp.is_a?(Backreference::NumberRelative)
   end
 
   def test_parse_backref_number_relative_sq
-    t = RP.parse("(abc)\\k'-1'", 'ruby/1.9')[1]
+    root = RP.parse("(abc)\\k'-1'", 'ruby/1.9')
+    exp  = root.expressions.at(1)
 
-    assert_equal( true,  t.is_a?(Backreference::NumberRelative) )
+    assert_equal true, exp.is_a?(Backreference::NumberRelative)
   end
 
   def test_parse_backref_name_call_ab
-    t = RP.parse('(?<X>abc)\g<X>', 'ruby/1.9')[1]
+    root = RP.parse('(?<X>abc)\g<X>', 'ruby/1.9')
+    exp  = root.expressions.at(1)
 
-    assert_equal( true,  t.is_a?(Backreference::NameCall) )
+    assert_equal true, exp.is_a?(Backreference::NameCall)
   end
 
   def test_parse_backref_name_call_sq
-    t = RP.parse("(?<X>abc)\\g'X'", 'ruby/1.9')[1]
+    root = RP.parse("(?<X>abc)\\g'X'", 'ruby/1.9')
+    exp  = root.expressions.at(1)
 
-    assert_equal( true,  t.is_a?(Backreference::NameCall) )
+    assert_equal true, exp.is_a?(Backreference::NameCall)
   end
 
   def test_parse_backref_number_call_ab
-    t = RP.parse('(abc)\g<1>', 'ruby/1.9')[1]
+    root = RP.parse('(abc)\g<1>', 'ruby/1.9')
+    exp  = root.expressions.at(1)
 
-    assert_equal( true,  t.is_a?(Backreference::NumberCall) )
+    assert_equal true, exp.is_a?(Backreference::NumberCall)
   end
 
   def test_parse_backref_number_call_sq
-    t = RP.parse("(abc)\\g'1'", 'ruby/1.9')[1]
+    root = RP.parse("(abc)\\g'1'", 'ruby/1.9')
+    exp  = root.expressions.at(1)
 
-    assert_equal( true,  t.is_a?(Backreference::NumberCall) )
+    assert_equal true, exp.is_a?(Backreference::NumberCall)
   end
 
   def test_parse_backref_number_relative_call_ab
-    t = RP.parse('(abc)\g<-1>', 'ruby/1.9')[1]
+    root = RP.parse('(abc)\g<-1>', 'ruby/1.9')
+    exp  = root.expressions.at(1)
 
-    assert_equal( true,  t.is_a?(Backreference::NumberCallRelative) )
+    assert_equal true, exp.is_a?(Backreference::NumberCallRelative)
   end
 
   def test_parse_backref_number_relative_call_sq
-    t = RP.parse("(abc)\\g'-1'", 'ruby/1.9')[1]
+    root = RP.parse("(abc)\\g'-1'", 'ruby/1.9')
+    exp  = root.expressions.at(1)
 
-    assert_equal( true,  t.is_a?(Backreference::NumberCallRelative) )
+    assert_equal true, exp.is_a?(Backreference::NumberCallRelative)
   end
 
   def test_parse_backref_name_nest_level_ab
-    t = RP.parse('(?<X>abc)\k<X-0>', 'ruby/1.9')[1]
+    root = RP.parse('(?<X>abc)\k<X-0>', 'ruby/1.9')
+    exp  = root.expressions.at(1)
 
-    assert_equal( true,  t.is_a?(Backreference::NameNestLevel) )
+    assert_equal true, exp.is_a?(Backreference::NameNestLevel)
   end
 
   def test_parse_backref_name_nest_level_sq
-    t = RP.parse("(?<X>abc)\\k'X-0'", 'ruby/1.9')[1]
+    root = RP.parse("(?<X>abc)\\k'X-0'", 'ruby/1.9')
+    exp  = root.expressions.at(1)
 
-    assert_equal( true,  t.is_a?(Backreference::NameNestLevel) )
+    assert_equal true, exp.is_a?(Backreference::NameNestLevel)
   end
 
   def test_parse_backref_number_nest_level_ab
-    t = RP.parse('(abc)\k<1-0>', 'ruby/1.9')[1]
+    root = RP.parse('(abc)\k<1-0>', 'ruby/1.9')
+    exp  = root.expressions.at(1)
 
-    assert_equal( true,  t.is_a?(Backreference::NumberNestLevel) )
+    assert_equal true, exp.is_a?(Backreference::NumberNestLevel)
   end
 
   def test_parse_backref_number_nest_level_sq
-    t = RP.parse("(abc)\\k'1-0'", 'ruby/1.9')[1]
+    root = RP.parse("(abc)\\k'1-0'", 'ruby/1.9')
+    exp  = root.expressions.at(1)
 
-    assert_equal( true,  t.is_a?(Backreference::NumberNestLevel) )
+    assert_equal true, exp.is_a?(Backreference::NumberNestLevel)
   end
 
 end

data/test/parser/test_sets.rb

@@ -3,149 +3,163 @@ require File.expand_path("../../helpers", __FILE__)
 class TestParserSets < Test::Unit::TestCase
 
   def test_parse_set_basic
-    exp = RP.parse('[a-c]+', :any).expressions[0]
+    root = RP.parse('[a-c]+', :any)
+    exp  = root.expressions.at(0)
 
-    assert_equal( true, exp.is_a?(CharacterSet) )
-    assert_equal( true, exp.include?('a-c') )
+    assert_equal true, exp.is_a?(CharacterSet)
+    assert_equal true, exp.include?('a-c')
 
-    assert_equal( true, exp.quantified? )
-    assert_equal( 1,  exp.quantifier.min )
-    assert_equal( -1, exp.quantifier.max )
+    assert_equal true,  exp.quantified?
+    assert_equal 1,     exp.quantifier.min
+    assert_equal -1,    exp.quantifier.max
   end
 
   def test_parse_set_posix_class
-    exp = RP.parse('[[:digit:][:lower:]]+', 'ruby/1.9').expressions[0]
+    root = RP.parse('[[:digit:][:lower:]]+', 'ruby/1.9')
+    exp  = root.expressions.at(0)
 
-    assert_equal( true,  exp.is_a?(CharacterSet) )
+    assert_equal true,  exp.is_a?(CharacterSet)
 
-    assert_equal( true,  exp.include?('[:digit:]') )
-    assert_equal( true,  exp.include?('[:lower:]') )
+    assert_equal true,  exp.include?('[:digit:]')
+    assert_equal true,  exp.include?('[:lower:]')
 
-    assert_equal( true,  exp.matches?("6") )
+    assert_equal true,  exp.matches?("6")
 
-    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
-    exp = RP.parse('[ac-eh]', :any)[0]
+    root = RP.parse('[ac-eh]', :any)
+    exp  = root.expressions.at(0)
 
-    assert_equal( true,  exp.include?('a') )
-    assert_equal( true,  exp.include?('c-e') )
-    assert_equal( true,  exp.include?('h') )
-    assert_equal( false, exp.include?(']') )
+    assert_equal true,  exp.include?('a')
+    assert_equal true,  exp.include?('c-e')
+    assert_equal true,  exp.include?('h')
+    assert_equal false, exp.include?(']')
   end
 
   def test_parse_chat_type_set_members
-    exp = RP.parse('[\da-z]', :any)[0]
+    root = RP.parse('[\da-z]', :any)
+    exp  = root.expressions.at(0)
 
-    assert_equal( true,  exp.include?('\d') )
-    assert_equal( true,  exp.include?('a-z') )
+    assert_equal true,  exp.include?('\d')
+    assert_equal true,  exp.include?('a-z')
   end
 
   def test_parse_set_collating_sequence
-    exp = RP.parse('[a[.span-ll.]h]', :any)[0]
+    root = RP.parse('[a[.span-ll.]h]', :any)
+    exp  = root.expressions.at(0)
 
-    assert_equal( true,  exp.include?('[.span-ll.]') )
-    assert_equal( false, exp.include?(']') )
+    assert_equal true,  exp.include?('[.span-ll.]')
+    assert_equal false, exp.include?(']')
   end
 
   def test_parse_set_character_equivalents
-    exp = RP.parse('[a[=e=]h]', :any)[0]
+    root = RP.parse('[a[=e=]h]', :any)
+    exp  = root.expressions.at(0)
 
-    assert_equal( true,  exp.include?('[=e=]') )
-    assert_equal( false, exp.include?(']') )
+    assert_equal true,  exp.include?('[=e=]')
+    assert_equal false, exp.include?(']')
   end
 
   def test_parse_set_nesting_tos
     pattern = '[a[b[^c]]]'
+    root    = RP.parse(pattern, 'ruby/1.9')
 
-    assert_equal( pattern, RP.parse(pattern, 'ruby/1.9').to_s )
+    assert_equal pattern, root.to_s
   end
 
   def test_parse_set_nesting_include
-    exp = RP.parse('[a[b[^c]]]', 'ruby/1.9')[0]
+    root = RP.parse('[a[b[^c]]]', 'ruby/1.9')
+    exp  = root.expressions.at(0)
 
-    assert_equal( true, exp.is_a?(CharacterSet) )
-    assert_equal( true, exp.include?('a') )
-    assert_equal( true, exp.include?('b') )
-    assert_equal( true, exp.include?('c') )
+    assert_equal true, exp.is_a?(CharacterSet)
+    assert_equal true, exp.include?('a')
+    assert_equal true, exp.include?('b')
+    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') )
+    root = RP.parse('[a[b]c]', 'ruby/1.9')
+
+    exp = root.expressions.at(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.at(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) )
+    root = RP.parse('[a[b[c[d]e]f]g]', 'ruby/1.9')
+
+    exp = root.expressions.at(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.at(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.at(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.at(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]
+      root = RP.parse('[a[b[^c]]]', 'ruby/1.9')
+      exp  = root.expressions.at(0)
 
-      assert_equal( true,  exp.matches?("b") )
-      assert_equal( false, exp.matches?("c") )
+      assert_equal true,  exp.matches?('b')
+      assert_equal false, exp.matches?('c')
     end
 
     def test_parse_set_nesting_not_matches
-      exp = RP.parse('[a[b[^c]]]', 'ruby/1.9')[0]
-      assert_equal( false, exp.matches?("c") )
+      root = RP.parse('[a[b[^c]]]', 'ruby/1.9')
+      exp  = root.expressions.at(0)
+
+      assert_equal false, exp.matches?('c')
     end
 
     def test_parse_set_negated_posix_class
-      exp = RP.parse('[[:^xdigit:][:^lower:]]+', 'ruby/1.9').expressions[0]
+      root = RP.parse('[[:^xdigit:][:^lower:]]+', 'ruby/1.9')
+      exp  = root.expressions.at(0)
 
-      assert_equal( true,  exp.is_a?(CharacterSet) )
+      assert_equal true,  exp.is_a?(CharacterSet)
 
-      assert_equal( true,  exp.include?('[:^xdigit:]') )
-      assert_equal( true,  exp.include?('[:^lower:]') )
+      assert_equal true,  exp.include?('[:^xdigit:]')
+      assert_equal true,  exp.include?('[:^lower:]')
 
-      assert_equal( true,  exp.matches?("GT") )
+      assert_equal true,  exp.matches?('GT')
     end
   end
 

data/test/parser/test_types.rb

@@ -16,17 +16,16 @@ class TestParserTypes < Test::Unit::TestCase
     /a\Wc/    => [1, :type,   :nonword,   CharacterType::NonWord],
   }
 
-  count = 0
-  tests.each do |pattern, test|
-    define_method "test_parse_type_#{test[2]}_#{count+=1}" do
+  tests.each_with_index do |(pattern, (index, type, token, klass)), count|
+    define_method "test_parse_type_#{token}_#{count}" do
       root = RP.parse(pattern, 'ruby/1.9')
-      exp  = root.expressions[test[0]]
+      exp  = root.expressions.at(index)
 
-      assert( exp.is_a?( test[3] ),
-             "Expected #{test[3]}, but got #{exp.class.name}")
+      assert exp.is_a?( klass ),
+             "Expected #{klass}, but got #{exp.class.name}"
 
-      assert_equal( test[1], exp.type )
-      assert_equal( test[2], exp.token )
+      assert_equal type,  exp.type
+      assert_equal token, exp.token
     end
   end
 

data/test/scanner/test_all.rb

@@ -16,21 +16,23 @@ end
 class TestRegexpScanner < Test::Unit::TestCase
 
   def test_scanner_returns_an_array
-    assert_instance_of( Array, RS.scan('abc') )
+    assert_instance_of Array, RS.scan('abc')
   end
 
   def test_scanner_returns_tokens_as_arrays
     tokens = RS.scan('^abc+[^one]{2,3}\b\d\\\C-C$')
 
-    assert( tokens.all?{|token|
+    all_arrays = tokens.all? do |token|
       token.kind_of?(Array) and token.length == 5
-    }, "Not all tokens are arrays of 5 elements")
+    end
+
+    assert all_arrays, 'Not all tokens are arrays of 5 elements'
   end
 
   def test_scanner_token_count
     re = /^(one|two){2,3}([^d\]efm-qz\,\-]*)(ghi)+$/i
 
-    assert_equal(26, RS.scan(re).length )
+    assert_equal 26, RS.scan(re).length
   end
 
 end