regexp_parser 0.3.4 → 0.3.5

data/test/scanner/test_anchors.rb

@@ -22,13 +22,16 @@ class ScannerAnchors < Test::Unit::TestCase
    "a\\\\Bc"    => [1, :escape,    :backslash,              '\\\\', 1, 3],
   }
 
-  count = 0
-  tests.each do |pattern, test|
-    define_method "test_scanner_#{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[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_conditionals.rb

@@ -22,14 +22,16 @@ class ScannerConditionals < Test::Unit::TestCase
     /(?'N'A)(?('N')T|F)/  => [5, :conditional,  :condition,         "'N'", 10, 13],
   }
 
-  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)
-      token = tokens[test[0]]
-      assert_equal( test[1,5], token )
+      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
 
@@ -80,8 +82,14 @@ class ScannerConditionals < Test::Unit::TestCase
       [40, :conditional,  :close,           ')',  45, 46],
       [41, :conditional,  :close,           ')',  46, 47],
       [42, :conditional,  :close,           ')',  47, 48]
-    ].each do |test|
-      assert_equal( test[1,5], tokens[test[0]] )
+    ].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
 
@@ -139,8 +147,14 @@ class ScannerConditionals < Test::Unit::TestCase
       [47, :conditional,  :close,           ')',  50, 51],
       [48, :group,        :close,           ')',  51, 52],
       [49, :group,        :close,           ')',  52, 53]
-    ].each do |test|
-      assert_equal( test[1,5], tokens[test[0]] )
+    ].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
 
@@ -148,18 +162,22 @@ class ScannerConditionals < Test::Unit::TestCase
     regexp = /(a)(?(1)(b|c|d)|(e|f|g))(h)(?(2)(i|j|k)|(l|m|n))|o|p/
     tokens = RS.scan(regexp)
 
-    [9, 11, 17, 19, 32, 34, 40, 42, 46, 48].each do |token|
-      assert_equal(:meta,         tokens[token][0])
-      assert_equal(:alternation,  tokens[token][1])
-      assert_equal('|',           tokens[token][2])
-      assert_equal(1,             tokens[token][4] - tokens[token][3])
+    [9, 11, 17, 19, 32, 34, 40, 42, 46, 48].each do |index|
+      result = tokens[index]
+
+      assert_equal :meta,         result[0]
+      assert_equal :alternation,  result[1]
+      assert_equal '|',           result[2]
+      assert_equal 1,             result[4] - result[3]
     end
 
-    [14, 37].each do |token|
-      assert_equal(:conditional,  tokens[token][0])
-      assert_equal(:separator,    tokens[token][1])
-      assert_equal('|',           tokens[token][2])
-      assert_equal(1,             tokens[token][4] - tokens[token][3])
+    [14, 37].each do |index|
+      result = tokens[index]
+
+      assert_equal :conditional,  result[0]
+      assert_equal :separator,    result[1]
+      assert_equal '|',           result[2]
+      assert_equal 1,             result[4] - result[3]
     end
   end
 

data/test/scanner/test_escapes.rb

@@ -38,14 +38,16 @@ class ScannerEscapes < Test::Unit::TestCase
     'ab\\\Kcd'        => [1, :escape,  :backslash,        '\\\\',           2,  4],
   }
 
-  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)
-      token = tokens[test[0]]
-      assert_equal( test[1,5], token )
+      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_free_space.rb

@@ -13,21 +13,21 @@ class ScannerFreeSpace < Test::Unit::TestCase
     tokens = RS.scan(regexp)
 
     0.upto(24) do |i|
-      if i % 2 == 0
-        assert_equal( :free_space, tokens[i][0] )
-        assert_equal( :whitespace, tokens[i][1] )
+      if i.even?
+        assert_equal :free_space, tokens[i][0]
+        assert_equal :whitespace, tokens[i][1]
       else
-        assert_not_equal( :free_space, tokens[i][0] )
-        assert_not_equal( :whitespace, tokens[i][1] )
+        refute_equal :free_space, tokens[i][0]
+        refute_equal :whitespace, tokens[i][1]
       end
     end
 
     [0, 2, 10, 14].each do |i|
-      assert_equal( "\n      ",   tokens[i][2] )
+      assert_equal "\n      ",   tokens[i][2]
     end
 
     [4, 6, 8, 12].each do |i|
-      assert_equal( '  ',         tokens[i][2] )
+      assert_equal '  ',         tokens[i][2]
     end
   end
 
@@ -42,12 +42,18 @@ class ScannerFreeSpace < Test::Unit::TestCase
     tokens = RS.scan(regexp)
 
     [
-      [ 5, [:free_space, :comment,  "# A + comment\n",      11,  25]],
-      [11, [:free_space, :comment,  "# B ? comment\n",      37,  51]],
-      [17, [:free_space, :comment,  "# C {2,3} comment\n",  66,  84]],
-      [29, [:free_space, :comment,  "# D|E comment\n",     100, 114]],
-    ].each do |index, token|
-      assert_equal( token, tokens[index] )
+      [ 5, :free_space, :comment,  "# A + comment\n",      11,  25],
+      [11, :free_space, :comment,  "# B ? comment\n",      37,  51],
+      [17, :free_space, :comment,  "# C {2,3} comment\n",  66,  84],
+      [29, :free_space, :comment,  "# D|E comment\n",     100, 114],
+    ].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
 
@@ -57,17 +63,23 @@ class ScannerFreeSpace < Test::Unit::TestCase
     tokens = RS.scan(regexp)
 
     [
-      [0, [:literal,    :literal,     'a b',   0,  3]],
-      [1, [:group,      :options,     '(?x:',  3,  7]],
-      [2, [:literal,    :literal,     'c',     7,  8]],
-      [3, [:free_space, :whitespace,  ' ',     8,  9]],
-      [4, [:literal,    :literal,     'd',     9, 10]],
-      [5, [:free_space, :whitespace,  ' ',    10, 11]],
-      [6, [:literal,    :literal,     'e',    11, 12]],
-      [7, [:group,      :close,       ')',    12, 13]],
-      [8, [:literal,    :literal,     'f g',  13, 16]]
-    ].each do |index, token|
-      assert_equal( token, tokens[index] )
+      [0, :literal,    :literal,     'a b',   0,  3],
+      [1, :group,      :options,     '(?x:',  3,  7],
+      [2, :literal,    :literal,     'c',     7,  8],
+      [3, :free_space, :whitespace,  ' ',     8,  9],
+      [4, :literal,    :literal,     'd',     9, 10],
+      [5, :free_space, :whitespace,  ' ',    10, 11],
+      [6, :literal,    :literal,     'e',    11, 12],
+      [7, :group,      :close,       ')',    12, 13],
+      [8, :literal,    :literal,     'f g',  13, 16]
+    ].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
 
@@ -77,21 +89,27 @@ class ScannerFreeSpace < Test::Unit::TestCase
     tokens = RS.scan(regexp)
 
     [
-      [ 0, [:literal,     :literal,     'a b',     0,  3]],
-      [ 1, [:group,       :options,     '(?x:',    3,  7]],
-      [ 2, [:literal,     :literal,     'c',       7,  8]],
-      [ 3, [:free_space,  :whitespace,  ' ',       8,  9]],
-      [ 4, [:literal,     :literal,     'd',       9, 10]],
-      [ 5, [:group,       :options,     '(?-x:',  10, 15]],
-      [ 6, [:literal,     :literal,     'e f',    15, 18]],
-      [ 7, [:group,       :close,       ')',      18, 19]],
-      [ 8, [:literal,     :literal,     'g',      19, 20]],
-      [ 9, [:free_space,  :whitespace,  ' ',      20, 21]],
-      [10, [:literal,     :literal,     'h',      21, 22]],
-      [11, [:group,       :close,       ')',      22, 23]],
-      [12, [:literal,     :literal,     'i j',    23, 26]]
-    ].each do |index, token|
-      assert_equal( token, tokens[index] )
+      [ 0, :literal,     :literal,     'a b',     0,  3],
+      [ 1, :group,       :options,     '(?x:',    3,  7],
+      [ 2, :literal,     :literal,     'c',       7,  8],
+      [ 3, :free_space,  :whitespace,  ' ',       8,  9],
+      [ 4, :literal,     :literal,     'd',       9, 10],
+      [ 5, :group,       :options,     '(?-x:',  10, 15],
+      [ 6, :literal,     :literal,     'e f',    15, 18],
+      [ 7, :group,       :close,       ')',      18, 19],
+      [ 8, :literal,     :literal,     'g',      19, 20],
+      [ 9, :free_space,  :whitespace,  ' ',      20, 21],
+      [10, :literal,     :literal,     'h',      21, 22],
+      [11, :group,       :close,       ')',      22, 23],
+      [12, :literal,     :literal,     'i j',    23, 26]
+    ].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
 
@@ -101,32 +119,38 @@ class ScannerFreeSpace < Test::Unit::TestCase
     tokens = RS.scan(regexp)
 
     [
-      [ 0, [:group,       :capture,     '(',       0,  1]],
-      [ 1, [:literal,     :literal,     'a ',      1,  3]],
-      [ 2, [:group,       :capture,     '(',       3,  4]],
-      [ 3, [:literal,     :literal,     'b',       4,  5]],
-      [ 4, [:group,       :options,     '(?x:',    5,  9]],
-      [ 5, [:free_space,  :whitespace,  ' ',       9, 10]],
-      [ 6, [:group,       :capture,     '(',      10, 11]],
-      [ 7, [:literal,     :literal,     'c',      11, 12]],
-      [ 8, [:free_space,  :whitespace,  ' ',      12, 13]],
-      [ 9, [:literal,     :literal,     'd',      13, 14]],
-      [10, [:group,       :close,       ')',      14, 15]],
-      [11, [:free_space,  :whitespace,  ' ',      15, 16]],
-      [12, [:group,       :options,     '(?-x:',  16, 21]],
-      [13, [:group,       :capture,     '(',      21, 22]],
-      [14, [:literal,     :literal,     'e f',    22, 25]],
-      [15, [:group,       :close,       ')',      25, 26]],
-      [16, [:literal,     :literal,     ' ',      26, 27]],
-      [17, [:group,       :close,       ')',      27, 28]],
-      [18, [:literal,     :literal,     'g',      28, 29]],
-      [19, [:group,       :close,       ')',      29, 30]],
-      [20, [:literal,     :literal,     ' h',     30, 32]],
-      [21, [:group,       :close,       ')',      32, 33]],
-      [22, [:literal,     :literal,     'i j',    33, 36]],
-      [23, [:group,       :close,       ')',      36, 37]]
-    ].each do |index, token|
-      assert_equal( token, tokens[index] )
+      [ 0, :group,       :capture,     '(',       0,  1],
+      [ 1, :literal,     :literal,     'a ',      1,  3],
+      [ 2, :group,       :capture,     '(',       3,  4],
+      [ 3, :literal,     :literal,     'b',       4,  5],
+      [ 4, :group,       :options,     '(?x:',    5,  9],
+      [ 5, :free_space,  :whitespace,  ' ',       9, 10],
+      [ 6, :group,       :capture,     '(',      10, 11],
+      [ 7, :literal,     :literal,     'c',      11, 12],
+      [ 8, :free_space,  :whitespace,  ' ',      12, 13],
+      [ 9, :literal,     :literal,     'd',      13, 14],
+      [10, :group,       :close,       ')',      14, 15],
+      [11, :free_space,  :whitespace,  ' ',      15, 16],
+      [12, :group,       :options,     '(?-x:',  16, 21],
+      [13, :group,       :capture,     '(',      21, 22],
+      [14, :literal,     :literal,     'e f',    22, 25],
+      [15, :group,       :close,       ')',      25, 26],
+      [16, :literal,     :literal,     ' ',      26, 27],
+      [17, :group,       :close,       ')',      27, 28],
+      [18, :literal,     :literal,     'g',      28, 29],
+      [19, :group,       :close,       ')',      29, 30],
+      [20, :literal,     :literal,     ' h',     30, 32],
+      [21, :group,       :close,       ')',      32, 33],
+      [22, :literal,     :literal,     'i j',    33, 36],
+      [23, :group,       :close,       ')',      36, 37]
+    ].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
 

data/test/scanner/test_groups.rb

@@ -3,7 +3,7 @@ require File.expand_path("../../helpers", __FILE__)
 class ScannerGroups < Test::Unit::TestCase
 
   tests = {
-   ## Options
+    # Options
     '(?-mix:abc)'     => [0, :group,     :options,      '(?-mix:',    0, 7],
     '(?m-ix:abc)'     => [0, :group,     :options,      '(?m-ix:',    0, 7],
     '(?mi-x:abc)'     => [0, :group,     :options,      '(?mi-x:',    0, 7],
@@ -38,39 +38,34 @@ class ScannerGroups < Test::Unit::TestCase
     '(?<!abc)'        => [0, :assertion, :nlookbehind,  '(?<!',       0, 4],
   }
 
-  count = 0
-  tests.each do |pattern, test|
-    define_method "test_scan_#{test[1]}_#{test[2]}_#{count+=1}" 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]])
-
-    end
-  end
-
   if RUBY_VERSION >= '2.0'
-    option_tests = {
-      '(?m-dau:abc)'    => [0, :group,     :options,      '(?m-dau:',   0, 8],
-      '(?x-dmu:abc)'    => [0, :group,     :options,      '(?x-dmu:',   0, 8],
-      '(?-dau:abc)'     => [0, :group,     :options,      '(?-dau:',    0, 7],
-      '(?d-au:abc)'     => [0, :group,     :options,      '(?d-au:',    0, 7],
-      '(?da-u:abc)'     => [0, :group,     :options,      '(?da-u:',    0, 7],
-      '(?dau:abc)'      => [0, :group,     :options,      '(?dau:',     0, 6],
-      '(?dau)'          => [0, :group,     :options,      '(?dau',      0, 5],
-      '(?d:)'           => [0, :group,     :options,      '(?d:',       0, 4],
-      '(?a:)'           => [0, :group,     :options,      '(?a:',       0, 4],
-      '(?u:)'           => [0, :group,     :options,      '(?u:',       0, 4],
-    }
-
-    tests.each do |pattern, test|
-      define_method "test_scan_#{test[1]}_#{test[2]}_#{count+=1}" 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]])
+    tests.merge!({
+      # New options
+      '(?d-mix:abc)'  => [0, :group,     :options,      '(?d-mix:',   0, 8],
+      '(?a-mix:abc)'  => [0, :group,     :options,      '(?a-mix:',   0, 8],
+      '(?u-mix:abc)'  => [0, :group,     :options,      '(?u-mix:',   0, 8],
+      '(?da-m:abc)'   => [0, :group,     :options,      '(?da-m:',    0, 7],
+      '(?du-x:abc)'   => [0, :group,     :options,      '(?du-x:',    0, 7],
+      '(?dau-i:abc)'  => [0, :group,     :options,      '(?dau-i:',   0, 8],
+      '(?dau:abc)'    => [0, :group,     :options,      '(?dau:',     0, 6],
+      '(?dau)'        => [0, :group,     :options,      '(?dau',      0, 5],
+      '(?d:)'         => [0, :group,     :options,      '(?d:',       0, 4],
+      '(?a:)'         => [0, :group,     :options,      '(?a:',       0, 4],
+      '(?u:)'         => [0, :group,     :options,      '(?u:',       0, 4],
+    })
+  end
 
-      end
+  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)
+      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_keep.rb

@@ -3,31 +3,33 @@ require File.expand_path("../../helpers", __FILE__)
 class ScannerKeep < Test::Unit::TestCase
 
   def test_scan_keep_token
-    regexp = /ab\Kcd/
-    tokens = RS.scan(regexp)
-
-    assert_equal( :keep, tokens[1][0] )
-    assert_equal( :mark, tokens[1][1] )
-    assert_equal( '\\K', tokens[1][2] )
-    assert_equal( 2,     tokens[1][3] )
-    assert_equal( 4,     tokens[1][4] )
+    tokens = RS.scan(/ab\Kcd/)
+    result = tokens.at(1)
+
+    assert_equal :keep, result[0]
+    assert_equal :mark, result[1]
+    assert_equal '\\K', result[2]
+    assert_equal 2,     result[3]
+    assert_equal 4,     result[4]
   end
 
   def test_scan_keep_nested
-    regexp = /(a\Kb)|(c\\\Kd)ef/
-    tokens = RS.scan(regexp)
-
-    assert_equal( :keep, tokens[2][0] )
-    assert_equal( :mark, tokens[2][1] )
-    assert_equal( '\\K', tokens[2][2] )
-    assert_equal( 2,     tokens[2][3] )
-    assert_equal( 4,     tokens[2][4] )
-
-    assert_equal( :keep, tokens[9][0] )
-    assert_equal( :mark, tokens[9][1] )
-    assert_equal( '\\K', tokens[9][2] )
-    assert_equal( 11,    tokens[9][3] )
-    assert_equal( 13,    tokens[9][4] )
+    tokens = RS.scan(/(a\Kb)|(c\\\Kd)ef/)
+
+    first  = tokens.at(2)
+    second = tokens.at(9)
+
+    assert_equal :keep, first[0]
+    assert_equal :mark, first[1]
+    assert_equal '\\K', first[2]
+    assert_equal 2,     first[3]
+    assert_equal 4,     first[4]
+
+    assert_equal :keep, second[0]
+    assert_equal :mark, second[1]
+    assert_equal '\\K', second[2]
+    assert_equal 11,    second[3]
+    assert_equal 13,    second[4]
   end
 
 end