regexp_parser 0.3.4 → 0.3.5

data/test/scanner/test_literals.rb

@@ -70,15 +70,19 @@ class ScannerUTF8 < Test::Unit::TestCase
     },
   }
 
-  count = 0
-  tests.each do |pattern, checks|
-    define_method "test_scan_utf8_runs_#{count+=1}" do
-
+  tests.each_with_index do |(pattern, checks), count|
+    define_method "test_scanner_utf8_runs_#{count}" do
       tokens = RS.scan(pattern)
-      checks.each do |offset, token|
-        assert_equal( token, tokens[offset] )
-      end
 
+      checks.each do |index, (type, token, text, ts, te)|
+        result = tokens[index]
+
+        assert_equal type,  result[0]
+        assert_equal token, result[1]
+        assert_equal text,  result[2]
+        assert_equal ts,    result[3]
+        assert_equal te,    result[4]
+      end
     end
   end
 

data/test/scanner/test_meta.rb

@@ -21,15 +21,19 @@ class ScannerMeta < Test::Unit::TestCase
     },
   }
 
-  count = 0
-  tests.each do |pattern, checks|
-    define_method "test_scan_meta_alternation_#{count+=1}" do
-
+  tests.each_with_index do |(pattern, checks), count|
+    define_method "test_scanner_meta_alternation_#{count}" do
       tokens = RS.scan(pattern)
-      checks.each do |offset, token|
-        assert_equal( token, tokens[offset] )
-      end
 
+      checks.each do |index, (type, token, text, ts, te)|
+        result = tokens.at(index)
+
+        assert_equal type,  result[0]
+        assert_equal token, result[1]
+        assert_equal text,  result[2]
+        assert_equal ts,    result[3]
+        assert_equal te,    result[4]
+      end
     end
   end
 

data/test/scanner/test_properties.rb

@@ -293,27 +293,29 @@ class ScannerProperties < Test::Unit::TestCase
     'XID_Continue'                        => :xid_continue,
   }
 
-  count = 0
-  tests.each do |property, test|
-    define_method "test_scan_property_#{test}_#{count+=1}" do
-      token = RS.scan("a\\p{#{property}}c")[1]
+  tests.each_with_index do |(property, token), count|
+    define_method "test_scan_property_#{token}_#{count}" do
+      tokens = RS.scan("a\\p{#{property}}c")
+      result = tokens.at(1)
 
-      assert_equal( :property,      token[0] )
-      assert_equal( test,           token[1] )
+      assert_equal :property, result[0]
+      assert_equal token,     result[1]
     end
 
-    define_method "test_scan_nonproperty_#{test}_#{count+=1}" do
-      token = RS.scan("a\\P{#{property}}c")[1]
+    define_method "test_scan_nonproperty_#{token}_#{count}" do
+      tokens = RS.scan("a\\P{#{property}}c")
+      result = tokens.at(1)
 
-      assert_equal( :nonproperty,   token[0] )
-      assert_equal( test,           token[1] )
+      assert_equal :nonproperty, result[0]
+      assert_equal token,        result[1]
     end
 
-    define_method "test_scan_caret_nonproperty_#{test}_#{count+=1}" do
-      token = RS.scan("a\\p{^#{property}}c")[1]
+    define_method "test_scan_caret_nonproperty_#{token}_#{count}" do
+      tokens = RS.scan("a\\p{^#{property}}c")
+      result = tokens.at(1)
 
-      assert_equal( :nonproperty,   token[0] )
-      assert_equal( test,           token[1] )
+      assert_equal :nonproperty, result[0]
+      assert_equal token,        result[1]
     end
   end
 end

data/test/scanner/test_quantifiers.rb

@@ -21,17 +21,16 @@ class ScannerQuantifiers < Test::Unit::TestCase
    'a{2,4}' => [:quantifier,  :interval,                '{2,4}'],
   }
 
-  counter = 0
-  tests.each do |pattern, test|
-    name = (test[1] == :interval ? "interval_#{counter += 1}" : test[1])
+  tests.each_with_index do |(pattern, (type, token, text)), count|
+    name = (token == :interval ? "interval_#{count}" : token)
 
-    [:type, :token, :text].each_with_index do |member, i|
-      define_method "test_scan_#{test[0]}_#{name}_#{member}" do
+    define_method "test_scan_#{type}_#{name}" do
+      tokens = RS.scan(pattern)
+      result = tokens.last
 
-        token = RS.scan(pattern).last
-        assert_equal( test[i], token[i] )
-
-      end
+      assert_equal type,  result[0]
+      assert_equal token, result[1]
+      assert_equal text,  result[2]
     end
   end
 

data/test/scanner/test_refcalls.rb

@@ -4,41 +4,44 @@ class ScannerRefCalls < Test::Unit::TestCase
 
   tests = {
     # Group back-references, named, numbered, and relative
-    '(?<X>abc)\k<X>'  => [3, :backref, :name_ref_ab,        '\k<X>',      9, 14],
-    "(?<X>abc)\\k'X'" => [3, :backref, :name_ref_sq,        "\\k'X'",     9, 14],
+    '(?<X>abc)\k<X>'    => [3, :backref, :name_ref_ab,          '\k<X>',      9, 14],
+    "(?<X>abc)\\k'X'"   => [3, :backref, :name_ref_sq,          "\\k'X'",     9, 14],
 
-    '(abc)\k<1>'      => [3, :backref, :number_ref_ab,      '\k<1>',      5, 10],
-    "(abc)\\k'1'"     => [3, :backref, :number_ref_sq,      "\\k'1'",     5, 10],
+    '(abc)\k<1>'        => [3, :backref, :number_ref_ab,        '\k<1>',      5, 10],
+    "(abc)\\k'1'"       => [3, :backref, :number_ref_sq,        "\\k'1'",     5, 10],
 
-    '(abc)\k<-1>'     => [3, :backref, :number_rel_ref_ab,  '\k<-1>',     5, 11],
-    "(abc)\\k'-1'"    => [3, :backref, :number_rel_ref_sq,  "\\k'-1'",    5, 11],
+    '(abc)\k<-1>'       => [3, :backref, :number_rel_ref_ab,    '\k<-1>',     5, 11],
+    "(abc)\\k'-1'"      => [3, :backref, :number_rel_ref_sq,    "\\k'-1'",    5, 11],
 
     # Sub-expression invocation, named, numbered, and relative
-    '(?<X>abc)\g<X>'  => [3, :backref, :name_call_ab,        '\g<X>',      9, 14],
-    "(?<X>abc)\\g'X'" => [3, :backref, :name_call_sq,        "\\g'X'",     9, 14],
+    '(?<X>abc)\g<X>'    => [3, :backref, :name_call_ab,         '\g<X>',      9, 14],
+    "(?<X>abc)\\g'X'"   => [3, :backref, :name_call_sq,         "\\g'X'",     9, 14],
 
-    '(abc)\g<1>'      => [3, :backref, :number_call_ab,      '\g<1>',      5, 10],
-    "(abc)\\g'1'"     => [3, :backref, :number_call_sq,      "\\g'1'",     5, 10],
+    '(abc)\g<1>'        => [3, :backref, :number_call_ab,       '\g<1>',      5, 10],
+    "(abc)\\g'1'"       => [3, :backref, :number_call_sq,       "\\g'1'",     5, 10],
 
-    '(abc)\g<-1>'     => [3, :backref, :number_rel_call_ab,  '\g<-1>',     5, 11],
-    "(abc)\\g'-1'"    => [3, :backref, :number_rel_call_sq,  "\\g'-1'",    5, 11],
+    '(abc)\g<-1>'       => [3, :backref, :number_rel_call_ab,   '\g<-1>',     5, 11],
+    "(abc)\\g'-1'"      => [3, :backref, :number_rel_call_sq,   "\\g'-1'",    5, 11],
 
     # Group back-references, with nesting level
-    '(?<X>abc)\k<X-0>'  => [3, :backref, :name_nest_ref_ab,        '\k<X-0>',      9, 16],
-    "(?<X>abc)\\k'X-0'" => [3, :backref, :name_nest_ref_sq,        "\\k'X-0'",     9, 16],
+    '(?<X>abc)\k<X-0>'  => [3, :backref, :name_nest_ref_ab,     '\k<X-0>',    9, 16],
+    "(?<X>abc)\\k'X-0'" => [3, :backref, :name_nest_ref_sq,     "\\k'X-0'",   9, 16],
 
-    '(abc)\k<1-0>'      => [3, :backref, :number_nest_ref_ab,      '\k<1-0>',      5, 12],
-    "(abc)\\k'1-0'"     => [3, :backref, :number_nest_ref_sq,      "\\k'1-0'",     5, 12],
+    '(abc)\k<1-0>'      => [3, :backref, :number_nest_ref_ab,   '\k<1-0>',    5, 12],
+    "(abc)\\k'1-0'"     => [3, :backref, :number_nest_ref_sq,   "\\k'1-0'",   5, 12],
   }
 
-  count = 0
-  tests.each do |pattern, test|
-    define_method "test_scan_#{test[1]}_#{test[2]}_#{count+=1}" do
-
+  tests.each_with_index do |(pattern, (index, type, token, text, ts, te)), count|
+    define_method "test_scanner_#{type}_#{token}_#{count}" do
       tokens = RS.scan(pattern)
-      assert_equal( test[1,5], tokens[test[0]])
-      assert_equal( test[3],   pattern[tokens[test[0]][3], tokens[test[0]][4]])
-
+      result = tokens[index]
+
+      assert_equal type,  result[0]
+      assert_equal token, result[1]
+      assert_equal text,  result[2]
+      assert_equal ts,    result[3]
+      assert_equal te,    result[4]
+      assert_equal text,  pattern[ts, te]
     end
   end
 

data/test/scanner/test_scripts.rb

@@ -364,20 +364,21 @@ class ScannerUnicodeScripts < Test::Unit::TestCase
 	  'Unknown'                 => :script_unknown,
   }
 
-  count = 0
-  tests.each do |property, test|
-    define_method "test_scan_property_#{test}_#{count+=1}" do
-      token = RS.scan("a\\p{#{property}}c")[1]
+  tests.each_with_index do |(property, token), count|
+    define_method "test_scanner_property_#{token}_#{count}" do
+      tokens = RS.scan("a\\p{#{property}}c")
+      result = tokens.at(1)
 
-      assert_equal( :property,  token[0] )
-      assert_equal( test,       token[1] )
+      assert_equal :property, result[0]
+      assert_equal token,     result[1]
     end
 
-    define_method "test_scan_nonproperty_#{test}_#{count+=1}" do
-      token = RS.scan("a\\P{#{property}}c")[1]
+    define_method "test_scanner_nonproperty_#{token}_#{count}" do
+      tokens = RS.scan("a\\P{#{property}}c")
+      result = tokens.at(1)
 
-      assert_equal( :nonproperty,   token[0] )
-      assert_equal( test,           token[1] )
+      assert_equal :nonproperty, result[0]
+      assert_equal token,        result[1]
     end
   end
 

data/test/scanner/test_sets.rb

@@ -69,13 +69,16 @@ class ScannerSets < Test::Unit::TestCase
     '[a-w&&[^c-j]z]'        => [6, :subset, :close,           ']',          11, 12],
   }
 
-  count = 0
-  tests.each do |pattern, test|
-    define_method "test_scan_#{test[1]}_#{test[2]}_#{count+=1}" do
-
+  tests.each_with_index do |(pattern, (index, type, token, text, ts, te)), count|
+    define_method "test_scanner_#{type}_#{token}_#{count}" do
       tokens = RS.scan(pattern)
-      assert_equal( test[1,5], tokens[test[0]] )
+      result = tokens.at(index)
 
+      assert_equal type,  result[0]
+      assert_equal token, result[1]
+      assert_equal text,  result[2]
+      assert_equal ts,    result[3]
+      assert_equal te,    result[4]
     end
   end
 

data/test/scanner/test_types.rb

@@ -3,27 +3,29 @@ require File.expand_path("../../helpers", __FILE__)
 class ScannerTypes < Test::Unit::TestCase
 
   tests = {
-   'a\dc'       => [:type,  :digit,       '\d',  1],
-   'a\Dc'       => [:type,  :nondigit,    '\D',  1],
+   'a\dc' => [1, :type,  :digit,       '\d',  1, 3],
+   'a\Dc' => [1, :type,  :nondigit,    '\D',  1, 3],
 
-   'a\hc'       => [:type,  :hex,         '\h',  1],
-   'a\Hc'       => [:type,  :nonhex,      '\H',  1],
+   'a\hc' => [1, :type,  :hex,         '\h',  1, 3],
+   'a\Hc' => [1, :type,  :nonhex,      '\H',  1, 3],
 
-   'a\sc'       => [:type,  :space,       '\s',  1],
-   'a\Sc'       => [:type,  :nonspace,    '\S',  1],
+   'a\sc' => [1, :type,  :space,       '\s',  1, 3],
+   'a\Sc' => [1, :type,  :nonspace,    '\S',  1, 3],
 
-   'a\wc'       => [:type,  :word,        '\w',  1],
-   'a\Wc'       => [:type,  :nonword,     '\W',  1],
+   'a\wc' => [1, :type,  :word,        '\w',  1, 3],
+   'a\Wc' => [1, :type,  :nonword,     '\W',  1, 3],
   }
 
-  tests.each do |pattern, test|
-    [:type, :token, :text].each_with_index do |member, i|
-      define_method "test_scan_#{test[0]}_#{test[1]}_#{member}" do
+  tests.each do |(pattern, (index, type, token, text, ts, te))|
+    define_method "test_scanner_#{type}_#{token}" do
+      tokens = RS.scan(pattern)
+      result = tokens.at(index)
 
-        token = RS.scan(pattern)[test[3]]
-        assert_equal( test[i], token[i] )
-
-      end
+      assert_equal type,  result[0]
+      assert_equal token, result[1]
+      assert_equal text,  result[2]
+      assert_equal ts,    result[3]
+      assert_equal te,    result[4]
     end
   end
 

data/test/scanner/test_unicode_blocks.rb

@@ -110,20 +110,21 @@ class ScannerUnicodeBlocks < Test::Unit::TestCase
     'InYijing_Hexagram_Symbols'                 => :block_inyijing_hexagram_symbols
   }
 
-  count = 0
-  tests.each do |property, test|
-    define_method "test_scan_property_#{test}_#{count+=1}" do
-      token = RS.scan("a\\p{#{property}}c")[1]
+  tests.each_with_index do |(property, token), count|
+    define_method "test_scanner_property_#{token}_#{count}" do
+      tokens = RS.scan("a\\p{#{property}}c")
+      result = tokens.at(1)
 
-      assert_equal( :property,  token[0] )
-      assert_equal( test,       token[1] )
+      assert_equal :property, result[0]
+      assert_equal token,     result[1]
     end
 
-    define_method "test_scan_nonproperty_#{test}_#{count+=1}" do
-      token = RS.scan("a\\P{#{property}}c")[1]
+    define_method "test_scanner_nonproperty_#{token}_#{count}" do
+      tokens = RS.scan("a\\P{#{property}}c")
+      result = tokens.at(1)
 
-      assert_equal( :nonproperty,   token[0] )
-      assert_equal( test,           token[1] )
+      assert_equal :nonproperty, result[0]
+      assert_equal token,        result[1]
     end
   end
 

data/test/syntax/ruby/test_1.8.rb

@@ -35,21 +35,17 @@ class TestSyntaxRuby_V18 < Test::Unit::TestCase
   }
 
   tests.each do |method, types|
+    expected = method == :excludes ? false : true
+
     types.each do |type, tokens|
       if tokens.nil? or tokens.empty?
         define_method "test_syntax_ruby_v18_#{method}_#{type}" do
-          assert_equal(
-            method == :excludes ? false : true,
-            @syntax.implements?(type, nil)
-          )
+          assert_equal expected, @syntax.implements?(type, nil)
         end
       else
         tokens.each do |token|
           define_method "test_syntax_ruby_v18_#{method}_#{type}_#{token}" do
-            assert_equal(
-              method == :excludes ? false : true,
-              @syntax.implements?(type, token)
-            )
+            assert_equal expected, @syntax.implements?(type, token)
           end
         end
       end

data/test/syntax/ruby/test_1.9.1.rb

@@ -22,19 +22,13 @@ class TestSyntaxRuby_V191 < Test::Unit::TestCase
         Quantifier::Possessive
       ].flatten,
     },
-
-    :excludes => {
-    },
   }
 
   tests.each do |method, types|
     types.each do |type, tokens|
       tokens.each do |token|
         define_method "test_syntax_ruby_v191_#{method}_#{type}_#{token}" do
-          assert_equal(
-            method == :excludes ? false : true,
-            @syntax.implements?(type, token)
-          )
+          assert_equal true, @syntax.implements?(type, token)
         end
       end
     end

data/test/syntax/ruby/test_1.9.3.rb

@@ -17,19 +17,15 @@ class TestSyntaxRuby_V193 < Test::Unit::TestCase
         UnicodeProperty::Script_6_0 + UnicodeProperty::Age_V193
       ].flatten,
     },
-
-    :excludes => {
-    },
   }
 
   tests.each do |method, types|
+    expected = method == :excludes ? false : true
+
     types.each do |type, tokens|
       tokens.each do |token|
         define_method "test_syntax_ruby_v193_#{method}_#{type}_#{token}" do
-          assert_equal(
-            method == :excludes ? false : true,
-            @syntax.implements?(type, token)
-          )
+          assert_equal true, @syntax.implements?(type, token)
         end
       end
     end

data/test/syntax/ruby/test_2.0.0.rb

@@ -17,19 +17,13 @@ class TestSyntaxRuby_V200 < Test::Unit::TestCase
         UnicodeProperty::Age_V200
       ].flatten,
     },
-
-    :excludes => {
-    },
   }
 
   tests.each do |method, types|
     types.each do |type, tokens|
       tokens.each do |token|
         define_method "test_syntax_ruby_v200_#{method}_#{type}_#{token}" do
-          assert_equal(
-            method == :excludes ? false : true,
-            @syntax.implements?(type, token)
-          )
+          assert_equal true, @syntax.implements?(type, token)
         end
       end
     end

data/test/syntax/ruby/test_2.2.0.rb

@@ -17,19 +17,13 @@ class TestSyntaxRuby_V220 < Test::Unit::TestCase
         UnicodeProperty::Script_7_0 + UnicodeProperty::Age_V220
       ].flatten,
     },
-
-    :excludes => {
-    },
   }
 
   tests.each do |method, types|
     types.each do |type, tokens|
       tokens.each do |token|
         define_method "test_syntax_ruby_v220_#{method}_#{type}_#{token}" do
-          assert_equal(
-            method == :excludes ? false : true,
-            @syntax.implements?(type, token)
-          )
+          assert_equal true, @syntax.implements?(type, token)
         end
       end
     end

data/test/token/test_token.rb

@@ -6,38 +6,38 @@ class Token < Test::Unit::TestCase
     regexp = /ab?cd/
     tokens = RL.lex(regexp)
 
-    assert_equal( 'b',    tokens[1].text )
-    assert_equal( [1, 2], tokens[1].offset )
+    assert_equal 'b',    tokens[1].text
+    assert_equal [1, 2], tokens[1].offset
 
-    assert_equal( '?',    tokens[2].text )
-    assert_equal( [2, 3], tokens[2].offset )
+    assert_equal '?',    tokens[2].text
+    assert_equal [2, 3], tokens[2].offset
 
-    assert_equal( 'cd',   tokens[3].text )
-    assert_equal( [3, 5], tokens[3].offset )
+    assert_equal 'cd',   tokens[3].text
+    assert_equal [3, 5], tokens[3].offset
   end
 
   def test_token_length
     regexp = /abc?def/
     tokens = RL.lex(regexp)
 
-    assert_equal( 'ab',  tokens[0].text )
-    assert_equal( 2,     tokens[0].length )
+    assert_equal 'ab',  tokens[0].text
+    assert_equal 2,     tokens[0].length
 
-    assert_equal( 'c',   tokens[1].text )
-    assert_equal( 1,     tokens[1].length )
+    assert_equal 'c',   tokens[1].text
+    assert_equal 1,     tokens[1].length
 
-    assert_equal( '?',   tokens[2].text )
-    assert_equal( 1,     tokens[2].length )
+    assert_equal '?',   tokens[2].text
+    assert_equal 1,     tokens[2].length
 
-    assert_equal( 'def', tokens[3].text )
-    assert_equal( 3,     tokens[3].length )
+    assert_equal 'def', tokens[3].text
+    assert_equal 3,     tokens[3].length
   end
 
   def test_token_to_h
     regexp = /abc?def/
     tokens = RL.lex(regexp)
 
-    assert_equal( 'ab',  tokens[0].text )
+    assert_equal 'ab', tokens[0].text
     assert_equal({
         :type               => :literal,
         :token              => :literal,
@@ -47,11 +47,10 @@ class Token < Test::Unit::TestCase
         :level              => 0,
         :set_level          => 0,
         :conditional_level  => 0
-      },
-      tokens[0].to_h
+      }, tokens[0].to_h
     )
 
-    assert_equal( '?',   tokens[2].text )
+    assert_equal '?', tokens[2].text
     assert_equal({
         :type               => :quantifier,
         :token              => :zero_or_one,
@@ -61,8 +60,7 @@ class Token < Test::Unit::TestCase
         :level              => 0,
         :set_level          => 0,
         :conditional_level  => 0
-      },
-      tokens[2].to_h
+      }, tokens[2].to_h
     )
   end
 
@@ -71,18 +69,18 @@ class Token < Test::Unit::TestCase
     tokens = RL.lex(regexp)
 
     a = tokens.first
-    assert_equal( 'a',  a.text )
+    assert_equal 'a',  a.text
 
     plus = a.next
-    assert_equal( '+',  plus.text )
+    assert_equal '+',  plus.text
 
     b = plus.next
-    assert_equal( 'b',  b.text )
+    assert_equal 'b',  b.text
 
     interval = tokens.last
-    assert_equal( '{2,3}',  interval.text )
+    assert_equal '{2,3}',  interval.text
 
-    assert_equal( nil,  interval.next )
+    assert_equal nil,  interval.next
   end
 
   def test_token_previous
@@ -90,20 +88,20 @@ class Token < Test::Unit::TestCase
     tokens = RL.lex(regexp)
 
     interval = tokens.last
-    assert_equal( '{2,3}',  interval.text )
+    assert_equal '{2,3}',  interval.text
 
     d = interval.previous
-    assert_equal( 'd',  d.text )
+    assert_equal 'd',  d.text
 
     star = d.previous
-    assert_equal( '*',  star.text )
+    assert_equal '*',  star.text
 
     c = star.previous
-    assert_equal( 'c',  c.text )
+    assert_equal 'c',  c.text
 
     a = tokens.first
-    assert_equal( 'a',  a.text )
-    assert_equal( nil,  a.previous )
+    assert_equal 'a',  a.text
+    assert_equal nil,  a.previous
   end
 
 end