regexp_parser 1.4.0 → 1.7.1

data/test/scanner/test_errors.rb

@@ -1,91 +0,0 @@
-require File.expand_path("../../helpers", __FILE__)
-
-class ScannerErrors < Test::Unit::TestCase
-
-  def test_scanner_unbalanced_set
-    assert_raise( RS::PrematureEndError ) { RS.scan('[[:alpha:]') }
-  end
-
-  def test_scanner_unbalanced_group
-    assert_raise( RS::PrematureEndError ) { RS.scan('(abc') }
-  end
-
-  def test_scanner_unbalanced_interval
-    assert_raise( RS::PrematureEndError ) { RS.scan('a{1,2') }
-  end
-
-  def test_scanner_eof_in_property
-    assert_raise( RS::PrematureEndError ) { RS.scan('\p{asci') }
-  end
-
-  def test_scanner_incomplete_property
-    assert_raise( RS::PrematureEndError ) { RS.scan('\p{ascii abc') }
-  end
-
-  def test_scanner_unknown_property
-    assert_raise( RS::UnknownUnicodePropertyError ) { RS.scan('\p{foobar}') }
-  end
-
-  def test_scanner_incomplete_options
-    assert_raise( RS::ScannerError ) { RS.scan('(?mix abc)') }
-  end
-
-  def test_scanner_eof_options
-    assert_raise( RS::PrematureEndError ) { RS.scan('(?mix') }
-  end
-
-  def test_scanner_incorrect_options
-    assert_raise( RS::ScannerError ) { RS.scan('(?mix^bc') }
-  end
-
-  def test_scanner_eof_escape
-    assert_raise( RS::PrematureEndError ) { RS.scan('\\') }
-  end
-
-  def test_scanner_eof_in_hex_escape
-    assert_raise( RS::PrematureEndError ) { RS.scan('\x') }
-  end
-
-  def test_scanner_eof_in_codepoint_escape
-    assert_raise( RS::PrematureEndError ) { RS.scan('\u') }
-    assert_raise( RS::PrematureEndError ) { RS.scan('\u0') }
-    assert_raise( RS::PrematureEndError ) { RS.scan('\u00') }
-    assert_raise( RS::PrematureEndError ) { RS.scan('\u000') }
-    assert_raise( RS::PrematureEndError ) { RS.scan('\u{') }
-    assert_raise( RS::PrematureEndError ) { RS.scan('\u{00') }
-    assert_raise( RS::PrematureEndError ) { RS.scan('\u{0000') }
-    assert_raise( RS::PrematureEndError ) { RS.scan('\u{0000 ') }
-    assert_raise( RS::PrematureEndError ) { RS.scan('\u{0000 0000') }
-  end
-
-  def test_scanner_eof_in_control_sequence
-    assert_raise( RS::PrematureEndError ) { RS.scan('\c') }
-    assert_raise( RS::PrematureEndError ) { RS.scan('\c\M') }
-    assert_raise( RS::PrematureEndError ) { RS.scan('\c\M-') }
-    assert_raise( RS::PrematureEndError ) { RS.scan('\C') }
-    assert_raise( RS::PrematureEndError ) { RS.scan('\C-') }
-    assert_raise( RS::PrematureEndError ) { RS.scan('\C-\M') }
-    assert_raise( RS::PrematureEndError ) { RS.scan('\C-\M-') }
-  end
-
-  def test_scanner_eof_in_meta_sequence
-    assert_raise( RS::PrematureEndError ) { RS.scan('\M') }
-    assert_raise( RS::PrematureEndError ) { RS.scan('\M-') }
-    assert_raise( RS::PrematureEndError ) { RS.scan('\M-\\') }
-    assert_raise( RS::PrematureEndError ) { RS.scan('\M-\c') }
-    assert_raise( RS::PrematureEndError ) { RS.scan('\M-\C') }
-    assert_raise( RS::PrematureEndError ) { RS.scan('\M-\C-') }
-  end
-
-  def test_scanner_invalid_hex_escape
-    assert_raise( RS::InvalidSequenceError ) { RS.scan('\xZ') }
-    assert_raise( RS::InvalidSequenceError ) { RS.scan('\xZ0') }
-  end
-
-  def test_scanner_invalid_named_group
-    assert_raise( RS::InvalidGroupError ) { RS.scan("(?'')") }
-    assert_raise( RS::InvalidGroupError ) { RS.scan("(?''empty-name)") }
-    assert_raise( RS::InvalidGroupError ) { RS.scan("(?<>)") }
-    assert_raise( RS::InvalidGroupError ) { RS.scan("(?<>empty-name)") }
-  end
-end

data/test/scanner/test_escapes.rb

@@ -1,56 +0,0 @@
-require File.expand_path("../../helpers", __FILE__)
-
-class ScannerEscapes < Test::Unit::TestCase
-
-  tests = {
-    /c\at/            => [1, :escape,  :bell,             '\a',             1,  3],
-
-    # not an escape outside a character set
-    /c\bt/            => [1, :anchor,  :word_boundary,    '\b',             1, 3],
-
-    /c\ft/            => [1, :escape,  :form_feed,        '\f',             1,  3],
-    /c\nt/            => [1, :escape,  :newline,          '\n',             1,  3],
-    /c\tt/            => [1, :escape,  :tab,              '\t',             1,  3],
-    /c\vt/            => [1, :escape,  :vertical_tab,     '\v',             1,  3],
-
-    'c\qt'            => [1, :escape,  :literal,          '\q',             1,  3],
-
-    'a\012c'          => [1, :escape,  :octal,            '\012',           1,  5],
-    'a\0124'          => [1, :escape,  :octal,            '\012',           1,  5],
-    '\712+7'          => [0, :escape,  :octal,            '\712',           0,  4],
-
-    'a\x24c'          => [1, :escape,  :hex,              '\x24',           1,  5],
-    'a\x0640c'        => [1, :escape,  :hex,              '\x06',           1,  5],
-
-    'a\u0640c'        => [1, :escape,  :codepoint,        '\u0640',         1,  7],
-    'a\u{640 0641}c'  => [1, :escape,  :codepoint_list,   '\u{640 0641}',   1,  13],
-    'a\u{10FFFF}c'    => [1, :escape,  :codepoint_list,   '\u{10FFFF}',     1,  11],
-
-    /a\cBc/           => [1, :escape,  :control,          '\cB',            1,  4],
-    /a\C-bc/          => [1, :escape,  :control,          '\C-b',           1,  5],
-    /a\c\M-Bc/n       => [1, :escape,  :control,          '\c\M-B',         1,  7],
-    /a\C-\M-Bc/n      => [1, :escape,  :control,          '\C-\M-B',        1,  8],
-
-    /a\M-Bc/n         => [1, :escape,  :meta_sequence,    '\M-B',           1,  5],
-    /a\M-\C-Bc/n      => [1, :escape,  :meta_sequence,    '\M-\C-B',        1,  8],
-    /a\M-\cBc/n       => [1, :escape,  :meta_sequence,    '\M-\cB',         1,  7],
-
-    'ab\\\xcd'        => [1, :escape,  :backslash,        '\\\\',           2,  4],
-    'ab\\\0cd'        => [1, :escape,  :backslash,        '\\\\',           2,  4],
-    'ab\\\Kcd'        => [1, :escape,  :backslash,        '\\\\',           2,  4],
-  }
-
-  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.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_free_space.rb

@@ -1,200 +0,0 @@
-require File.expand_path("../../helpers", __FILE__)
-
-class ScannerFreeSpace < Test::Unit::TestCase
-
-  def test_scan_free_space_tokens
-    regexp = %r{
-      a
-      b  ?  c  *
-      d  {2,3}
-      e + | f +
-    }x
-
-    tokens = RS.scan(regexp)
-
-    0.upto(24) do |i|
-      if i.even?
-        assert_equal :free_space, tokens[i][0]
-        assert_equal :whitespace, tokens[i][1]
-      else
-        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]
-    end
-
-    [4, 6, 8, 12].each do |i|
-      assert_equal '  ',         tokens[i][2]
-    end
-  end
-
-  def test_scan_free_space_comments
-    regexp = %r{
-      a + # A + comment
-      b  ?  # B ? comment
-      c  {2,3} # C {2,3} comment
-      d + | e + # D|E comment
-    }x
-
-    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, 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
-
-  def test_scan_free_space_inlined
-    # Matches 'a bcdef g'
-    regexp = /a b(?x:c d e)f g/
-    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, 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
-
-  def test_scan_free_space_nested
-    # Matches 'a bcde fghi j'
-    regexp = /a b(?x:c d(?-x:e f)g h)i j/
-    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, 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
-
-  def test_scan_free_space_nested_groups
-    # Matches 'a bcde f g hi j'
-    regexp = /(a (b(?x: (c d) (?-x:(e f) )g) h)i j)/
-    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, 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
-
-  def test_scan_free_space_switch_groups
-    # Matches 'a bcde f g hi j'
-    regexp = /(a (b((?x) (c d) ((?-x)(e f) )g) h)i j)/
-    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,      :capture,        '(',     5,  6],
-      [ 5, :group,      :options_switch, '(?x',   6,  9],
-      [ 6, :group,      :close,           ')',    9,  10],
-      [ 7, :free_space, :whitespace,      ' ',    10, 11],
-      [ 8, :group,      :capture,         '(',    11, 12],
-      [ 9, :literal,    :literal,         'c',    12, 13],
-      [10, :free_space, :whitespace,      ' ',    13, 14],
-      [11, :literal,    :literal,         'd',    14, 15],
-      [12, :group,      :close,           ')',    15, 16],
-      [13, :free_space, :whitespace,      ' ',    16, 17],
-      [14, :group,      :capture,         '(',    17, 18],
-      [15, :group,      :options_switch, '(?-x',  18, 22],
-      [16, :group,      :close,          ')',     22, 23],
-      [17, :group,      :capture,        '(',     23, 24],
-      [18, :literal,    :literal,        'e f',   24, 27],
-      [19, :group,      :close,          ')',     27, 28],
-      [20, :literal,    :literal,        ' ',     28, 29],
-      [21, :group,      :close,          ')',     29, 30],
-      [22, :literal,    :literal,        'g',     30, 31],
-      [23, :group,      :close,          ')',     31, 32],
-      [24, :literal,    :literal,        ' h',    32, 34],
-      [25, :group,      :close,          ')',     34, 35],
-      [26, :literal,    :literal,        'i j',   35, 38],
-      [27, :group,      :close,          ')',     38, 39]
-    ].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_groups.rb

@@ -1,79 +0,0 @@
-require File.expand_path("../../helpers", __FILE__)
-
-class ScannerGroups < Test::Unit::TestCase
-
-  tests = {
-    # 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],
-    '(?mix:abc)'      => [0, :group,     :options,        '(?mix:',     0, 6],
-    '(?m:)'           => [0, :group,     :options,        '(?m:',       0, 4],
-    '(?i:)'           => [0, :group,     :options,        '(?i:',       0, 4],
-    '(?x:)'           => [0, :group,     :options,        '(?x:',       0, 4],
-    '(?mix)'          => [0, :group,     :options_switch, '(?mix',      0, 5],
-
-    # Group types
-    '(?>abc)'         => [0, :group,     :atomic,         '(?>',        0, 3],
-    '(abc)'           => [0, :group,     :capture,        '(',          0, 1],
-
-    '(?<name>abc)'    => [0, :group,     :named_ab,       '(?<name>',   0, 8],
-    "(?'name'abc)"    => [0, :group,     :named_sq,       "(?'name'",   0, 8],
-
-    '(?<name_1>abc)'  => [0, :group,     :named_ab,       '(?<name_1>', 0,10],
-    "(?'name_1'abc)"  => [0, :group,     :named_sq,       "(?'name_1'", 0,10],
-
-    '(?:abc)'         => [0, :group,     :passive,        '(?:',        0, 3],
-    '(?:)'            => [0, :group,     :passive,        '(?:',        0, 3],
-    '(?::)'           => [0, :group,     :passive,        '(?:',        0, 3],
-
-    # Comments
-    '(?#abc)'         => [0, :group,     :comment,        '(?#abc)',    0, 7],
-    '(?#)'            => [0, :group,     :comment,        '(?#)',       0, 4],
-
-    # Assertions
-    '(?=abc)'         => [0, :assertion, :lookahead,      '(?=',        0, 3],
-    '(?!abc)'         => [0, :assertion, :nlookahead,     '(?!',        0, 3],
-    '(?<=abc)'        => [0, :assertion, :lookbehind,     '(?<=',       0, 4],
-    '(?<!abc)'        => [0, :assertion, :nlookbehind,    '(?<!',       0, 4],
-  }
-
-  if RUBY_VERSION >= '2.0'
-    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],
-      '(?d:)'         => [0, :group,     :options,        '(?d:',       0, 4],
-      '(?a:)'         => [0, :group,     :options,        '(?a:',       0, 4],
-      '(?u:)'         => [0, :group,     :options,        '(?u:',       0, 4],
-      '(?dau)'        => [0, :group,     :options_switch, '(?dau',      0, 5],
-    })
-  end
-
-  if RUBY_VERSION >= '2.4.1'
-    tests.merge!({
-      # New absence operator
-      '(?~abc)'       => [0, :group,     :absence,        '(?~',        0, 3],
-    })
-  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
-
-end

data/test/scanner/test_keep.rb

@@ -1,35 +0,0 @@
-require File.expand_path("../../helpers", __FILE__)
-
-class ScannerKeep < Test::Unit::TestCase
-
-  def test_scan_keep_token
-    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
-    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