regexp_parser 1.3.0 → 1.7.0

data/test/scanner/test_refcalls.rb

@@ -1,52 +0,0 @@
-require File.expand_path("../../helpers", __FILE__)
-
-class ScannerRefCalls < Test::Unit::TestCase
-  tests = {
-    # Traditional numerical group back-reference
-    '(abc)\1'           => [3, :backref, :number,                  '\1',         5, 7],
-
-    # 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],
-
-    '(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],
-
-    # 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],
-
-    '(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],
-
-    '\g<+1>(abc)'       => [0, :backref, :number_rel_call_ab,      '\g<+1>',     0, 6],
-    "\\g'+1'(abc)"      => [0, :backref, :number_rel_call_sq,      "\\g'+1'",    0, 6],
-
-    # Group back-references, with recursion level
-    '(?<X>abc)\k<X-0>'  => [3, :backref, :name_recursion_ref_ab,   '\k<X-0>',    9, 16],
-    "(?<X>abc)\\k'X-0'" => [3, :backref, :name_recursion_ref_sq,   "\\k'X-0'",   9, 16],
-
-    '(abc)\k<1-0>'      => [3, :backref, :number_recursion_ref_ab, '\k<1-0>',    5, 12],
-    "(abc)\\k'1-0'"     => [3, :backref, :number_recursion_ref_sq, "\\k'1-0'",   5, 12],
-  }
-
-  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_scripts.rb

@@ -1,53 +0,0 @@
-require File.expand_path("../../helpers", __FILE__)
-
-class ScannerUnicodeScripts < Test::Unit::TestCase
-
-  tests = {
-    'Aghb'	                  => :caucasian_albanian,
-    'Caucasian Albanian'	    => :caucasian_albanian,
-
-    'Arab'	                  => :arabic,
-    'Arabic'	                => :arabic,
-
-    'Armi'	                  => :imperial_aramaic,
-    'Imperial Aramaic'        => :imperial_aramaic,
-
-    'Egyp'                    => :egyptian_hieroglyphs,
-    'Egyptian Hieroglyphs'    => :egyptian_hieroglyphs, # test whitespace
-
-    'Linb'                    => :linear_b,
-    'Linear-B'                => :linear_b, # test dash
-
-    'Yiii'                    => :yi,
-    'Yi'                      => :yi,
-
-    'Zinh'                    => :inherited,
-    'Inherited'               => :inherited,
-    'Qaai'                    => :inherited,
-
-    'Zyyy'                    => :common,
-    'Common'                  => :common,
-
-    'Zzzz'                    => :unknown,
-    'Unknown'                 => :unknown,
-  }
-
-  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, result[0]
-      assert_equal token,     result[1]
-    end
-
-    define_method "test_scanner_nonproperty_#{token}_#{count}" do
-      tokens = RS.scan("a\\P{#{property}}c")
-      result = tokens.at(1)
-
-      assert_equal :nonproperty, result[0]
-      assert_equal token,        result[1]
-    end
-  end
-
-end

data/test/scanner/test_sets.rb

@@ -1,119 +0,0 @@
-# encoding: utf-8
-
-require File.expand_path("../../helpers", __FILE__)
-
-class ScannerSets < Test::Unit::TestCase
-
-  tests = {
-    '[a]'                   => [0, :set,    :open,            '[',          0, 1],
-    '[b]'                   => [2, :set,    :close,           ']',          2, 3],
-    '[^n]'                  => [1, :set,    :negate,          '^',          1, 2],
-
-    '[c]'                   => [1, :literal, :literal,        'c',          1, 2],
-    '[\b]'                  => [1, :escape,  :backspace,      '\b',         1, 3],
-    '[A\bX]'                => [2, :escape,  :backspace,      '\b',         2, 4],
-
-    '[.]'                   => [1, :literal, :literal,        '.',          1, 2],
-    '[?]'                   => [1, :literal, :literal,        '?',          1, 2],
-    '[*]'                   => [1, :literal, :literal,        '*',          1, 2],
-    '[+]'                   => [1, :literal, :literal,        '+',          1, 2],
-    '[{]'                   => [1, :literal, :literal,        '{',          1, 2],
-    '[}]'                   => [1, :literal, :literal,        '}',          1, 2],
-    '[<]'                   => [1, :literal, :literal,        '<',          1, 2],
-    '[>]'                   => [1, :literal, :literal,        '>',          1, 2],
-
-    '[äöü]'                 => [2, :literal, :literal,        'ö',          3, 5],
-
-    '[\x20]'                => [1, :escape, :hex,             '\x20',       1, 5],
-
-    '[\.]'                  => [1, :escape, :dot,             '\.',         1, 3],
-    '[\!]'                  => [1, :escape, :literal,         '\!',         1, 3],
-    '[\#]'                  => [1, :escape, :literal,         '\#',         1, 3],
-    '[\]]'                  => [1, :escape, :set_close,       '\]',         1, 3],
-    '[\\\]'                 => [1, :escape, :backslash,       '\\\\',       1, 3],
-    '[\A]'                  => [1, :escape, :literal,         '\A',         1, 3],
-    '[\z]'                  => [1, :escape, :literal,         '\z',         1, 3],
-    '[\g]'                  => [1, :escape, :literal,         '\g',         1, 3],
-    '[\K]'                  => [1, :escape, :literal,         '\K',         1, 3],
-    '[\c2]'                 => [1, :escape, :literal,         '\c',         1, 3],
-    '[\B]'                  => [1, :escape, :literal,         '\B',         1, 3],
-    '[a\-c]'                => [2, :escape, :literal,         '\-',         2, 4],
-
-    '[\d]'                  => [1, :type,   :digit,           '\d',         1, 3],
-    '[\da-z]'               => [1, :type,   :digit,           '\d',         1, 3],
-    '[\D]'                  => [1, :type,   :nondigit,        '\D',         1, 3],
-
-    '[\h]'                  => [1, :type,   :hex,             '\h',         1, 3],
-    '[\H]'                  => [1, :type,   :nonhex,          '\H',         1, 3],
-
-    '[\s]'                  => [1, :type,   :space,           '\s',         1, 3],
-    '[\S]'                  => [1, :type,   :nonspace,        '\S',         1, 3],
-
-    '[\w]'                  => [1, :type,   :word,            '\w',         1, 3],
-    '[\W]'                  => [1, :type,   :nonword,         '\W',         1, 3],
-
-    '[\R]'                  => [1, :escape, :literal,         '\R',         1, 3],
-    '[\X]'                  => [1, :escape, :literal,         '\X',         1, 3],
-
-    '[a-b]'                 => [1, :literal, :literal,        'a',          1, 2],
-    '[a-c]'                 => [2, :set,     :range,          '-',          2, 3],
-    '[a-d]'                 => [3, :literal, :literal,        'd',          3, 4],
-    '[a-b-]'                => [4, :literal, :literal,        '-',          4, 6],
-    '[-a]'                  => [1, :literal, :literal,        '-',          1, 2],
-    '[a-c^]'                => [4, :literal, :literal,        '^',          4, 5],
-    '[a-bd-f]'              => [2, :set,    :range,           '-',          2, 3],
-    '[a-cd-f]'              => [5, :set,    :range,           '-',          5, 6],
-
-    '[a[:digit:]c]'         => [2, :posixclass,    :digit,    '[:digit:]',  2, 11],
-    '[[:digit:][:space:]]'  => [2, :posixclass,    :space,    '[:space:]', 10, 19],
-    '[[:^digit:]]'          => [1, :nonposixclass, :digit,    '[:^digit:]', 1, 11],
-
-    '[a[.a-b.]c]'           => [2, :set,    :collation,       '[.a-b.]',    2,  9],
-    '[a[=e=]c]'             => [2, :set,    :equivalent,      '[=e=]',      2,  7],
-
-    '[a-d&&g-h]'            => [4, :set,    :intersection,    '&&',         4, 6],
-    '[a&&]'                 => [2, :set,    :intersection,    '&&',         2, 4],
-    '[&&z]'                 => [1, :set,    :intersection,    '&&',         1, 3],
-
-    '[\\x20-\\x27]'         => [1, :escape, :hex,             '\x20',       1, 5],
-    '[\\x20-\\x28]'         => [2, :set,    :range,           '-',          5, 6],
-    '[\\x20-\\x29]'         => [3, :escape, :hex,             '\x29',       6, 10],
-
-    '[a\p{digit}c]'         => [2, :property,    :digit,      '\p{digit}',  2, 11],
-    '[a\P{digit}c]'         => [2, :nonproperty, :digit,      '\P{digit}',  2, 11],
-    '[a\p{^digit}c]'        => [2, :nonproperty, :digit,      '\p{^digit}', 2, 12],
-    '[a\P{^digit}c]'        => [2, :property,    :digit,      '\P{^digit}', 2, 12],
-
-    '[a\p{ALPHA}c]'         => [2, :property,    :alpha,      '\p{ALPHA}',  2, 11],
-    '[a\p{P}c]'             => [2, :property,    :punctuation,'\p{P}',      2, 7],
-    '[a\p{P}\P{P}c]'        => [3, :nonproperty, :punctuation,'\P{P}',      7, 12],
-
-    '[a-w&&[^c-g]z]'        => [5, :set,    :open,            '[',          6, 7],
-    '[a-w&&[^c-h]z]'        => [6, :set,    :negate,          '^',          7, 8],
-    '[a-w&&[^c-i]z]'        => [8, :set,    :range,           '-',          9, 10],
-    '[a-w&&[^c-j]z]'        => [10,:set,    :close,           ']',          11, 12],
-  }
-
-  tests.each_with_index do |(pattern, (index, type, token, text, ts, te)), count|
-    define_method "test_scanner_#{type}_#{token}_in_'#{pattern}'_#{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
-
-  def test_set_literal_encoding
-    text = RS.scan('[a]')[1][2].to_s
-    assert_equal 'a',     text
-    assert_equal 'UTF-8', text.encoding.to_s
-
-    text = RS.scan('[😲]')[1][2].to_s
-    assert_equal '😲',     text
-    assert_equal 'UTF-8', text.encoding.to_s
-  end
-end

data/test/scanner/test_types.rb

@@ -1,35 +0,0 @@
-require File.expand_path("../../helpers", __FILE__)
-
-class ScannerTypes < Test::Unit::TestCase
-
-  tests = {
-   'a\dc' => [1, :type,  :digit,       '\d',  1, 3],
-   'a\Dc' => [1, :type,  :nondigit,    '\D',  1, 3],
-
-   'a\hc' => [1, :type,  :hex,         '\h',  1, 3],
-   'a\Hc' => [1, :type,  :nonhex,      '\H',  1, 3],
-
-   'a\sc' => [1, :type,  :space,       '\s',  1, 3],
-   'a\Sc' => [1, :type,  :nonspace,    '\S',  1, 3],
-
-   'a\wc' => [1, :type,  :word,        '\w',  1, 3],
-   'a\Wc' => [1, :type,  :nonword,     '\W',  1, 3],
-
-   'a\Rc' => [1, :type,  :linebreak,   '\R',  1, 3],
-   'a\Xc' => [1, :type,  :xgrapheme,   '\X',  1, 3],
-  }
-
-  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)
-
-      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_unicode_blocks.rb

@@ -1,30 +0,0 @@
-require File.expand_path("../../helpers", __FILE__)
-
-class ScannerUnicodeBlocks < Test::Unit::TestCase
-
-  tests = {
-    'InArabic'                                  => :in_arabic,
-    'InCJK_Unified_Ideographs_Extension_A'      => :in_cjk_unified_ideographs_extension_a,
-    'In Letterlike Symbols'                     => :in_letterlike_symbols,
-    'InMiscellaneous_Mathematical_Symbols-A'    => :in_miscellaneous_mathematical_symbols_a,
-  }
-
-  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, result[0]
-      assert_equal token,     result[1]
-    end
-
-    define_method "test_scanner_nonproperty_#{token}_#{count}" do
-      tokens = RS.scan("a\\P{#{property}}c")
-      result = tokens.at(1)
-
-      assert_equal :nonproperty, result[0]
-      assert_equal token,        result[1]
-    end
-  end
-
-end

data/test/support/disable_autotest.rb

@@ -1,8 +0,0 @@
-require 'test/unit/autorunner'
-
-module Test::Unit
-  class AutoRunner
-    def self.need_auto_run?
-    end
-  end
-end

data/test/syntax/test_all.rb

@@ -1,6 +0,0 @@
-require File.expand_path("../../helpers", __FILE__)
-
-require File.expand_path("../test_syntax", __FILE__)
-require File.expand_path("../versions/test_all", __FILE__)
-
-require File.expand_path("../test_syntax_token_map", __FILE__)

data/test/syntax/test_syntax.rb

@@ -1,61 +0,0 @@
-require File.expand_path("../../helpers", __FILE__)
-
-class TestSyntax < Test::Unit::TestCase
-
-  def test_syntax_unknown_name
-    assert_raise( Regexp::Syntax::UnknownSyntaxNameError ) {
-      Regexp::Syntax.new('ruby/1.0')
-    }
-  end
-
-  def test_syntax_new
-    assert_instance_of Regexp::Syntax::V1_9_3,
-                       Regexp::Syntax.new('ruby/1.9.3')
-  end
-
-  def test_syntax_new_any
-    assert_instance_of Regexp::Syntax::Any,
-                       Regexp::Syntax.new('any')
-    assert_instance_of Regexp::Syntax::Any,
-                       Regexp::Syntax.new('*')
-  end
-
-  def test_syntax_not_implemented
-    assert_raise( Regexp::Syntax::NotImplementedError ) {
-      RP.parse('\p{alpha}', 'ruby/1.8')
-    }
-  end
-
-  def test_syntax_supported?
-    assert_equal false, Regexp::Syntax.supported?('ruby/1.1.1')
-    assert_equal true, Regexp::Syntax.supported?('ruby/2.4.3')
-    assert_equal true, Regexp::Syntax.supported?('ruby/2.5')
-  end
-
-  def test_syntax_invalid_version
-    assert_raise( Regexp::Syntax::InvalidVersionNameError ) {
-      Regexp::Syntax.version_class('2.0.0')
-    }
-
-    assert_raise( Regexp::Syntax::InvalidVersionNameError ) {
-      Regexp::Syntax.version_class('ruby/20')
-    }
-  end
-
-  def test_syntax_version_class_tiny_version
-    assert_equal Regexp::Syntax::V1_9_3,
-                 Regexp::Syntax.version_class('ruby/1.9.3')
-
-    assert_equal Regexp::Syntax::V2_3_1,
-                 Regexp::Syntax.version_class('ruby/2.3.1')
-  end
-
-  def test_syntax_version_class_minor_version
-    assert_equal Regexp::Syntax::V1_9,
-                 Regexp::Syntax.version_class('ruby/1.9')
-
-    assert_equal Regexp::Syntax::V2_3,
-                 Regexp::Syntax.version_class('ruby/2.3')
-  end
-
-end

data/test/syntax/test_syntax_token_map.rb

@@ -1,25 +0,0 @@
-require File.expand_path("../../helpers", __FILE__)
-
-class TestSyntaxTokenMap < Test::Unit::TestCase
-  def test_syntax_token_map_complete
-    map = Regexp::Syntax::Token::Map
-    latest_syntax = Regexp::Syntax.new 'ruby/2.9'
-
-    latest_syntax.features.each do |type, tokens|
-      tokens.each do |token|
-        assert map[type].include?(token),
-               "`#{type} #{token}` implemented but missing from Map"
-      end
-    end
-  end
-
-  def test_syntax_token_map_uniq
-    combinations = Regexp::Syntax::Token::Map.flat_map do |type, tokens|
-      tokens.map { |token| "#{type} #{token}" }
-    end
-
-    non_uniq = combinations.group_by { |str| str }.select { |_, v| v.count > 1 }
-
-    assert_empty non_uniq.keys
-  end
-end

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

@@ -1,55 +0,0 @@
-require File.expand_path("../../../helpers", __FILE__)
-
-class TestSyntaxV1_8 < Test::Unit::TestCase
-  include Regexp::Syntax::Token
-
-  def setup
-    @syntax = Regexp::Syntax.new 'ruby/1.8'
-  end
-
-  tests = {
-    implements: {
-      assertion:    [Assertion::Lookahead].flatten,
-      backref:      [:number],
-      escape:       [
-        Escape::Basic + Escape::ASCII + Escape::Meta + Escape::Control
-      ].flatten,
-      group:        [Group::V1_8_6].flatten,
-      quantifier:   [
-          Quantifier::Greedy + Quantifier::Reluctant +
-          Quantifier::Interval + Quantifier::IntervalReluctant
-      ].flatten,
-    },
-
-    excludes: {
-      assertion: [Assertion::Lookbehind].flatten,
-
-      backref: [
-        Backreference::All - [:number] + SubexpressionCall::All
-      ].flatten,
-
-      quantifier: [
-        Quantifier::Possessive
-      ].flatten
-    },
-  }
-
-  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_V1_8_#{method}_#{type}" do
-          assert_equal expected, @syntax.implements?(type, nil)
-        end
-      else
-        tokens.each do |token|
-          define_method "test_syntax_V1_8_#{method}_#{type}_#{token}" do
-            assert_equal expected, @syntax.implements?(type, token)
-          end
-        end
-      end
-    end
-  end
-
-end