regexp_parser 1.4.0 → 1.5.0

data/test/parser/test_sets.rb

@@ -1,179 +0,0 @@
-require File.expand_path("../../helpers", __FILE__)
-
-class TestParserSets < Test::Unit::TestCase
-  def test_parse_set_basic
-    root = RP.parse('[ab]+')
-    exp  = root[0]
-
-    assert_equal CharacterSet, exp.class
-    assert_equal 2, exp.count
-
-    assert_equal Literal, exp[0].class
-    assert_equal 'a', exp[0].text
-    assert_equal Literal, exp[1].class
-    assert_equal 'b', exp[1].text
-
-    assert       exp.quantified?
-    assert_equal 1, exp.quantifier.min
-    assert_equal(-1, exp.quantifier.max)
-  end
-
-  def test_parse_set_char_type
-    root = RP.parse('[a\dc]')
-    exp  = root[0]
-
-    assert_equal CharacterSet, exp.class
-    assert_equal 3, exp.count
-
-    assert_equal CharacterType::Digit, exp[1].class
-    assert_equal '\d', exp[1].text
-  end
-
-  def test_parse_set_escape_sequence_backspace
-    root = RP.parse('[a\bc]')
-    exp  = root[0]
-
-    assert_equal CharacterSet, exp.class
-    assert_equal 3, exp.count
-
-    assert_equal EscapeSequence::Backspace, exp[1].class
-    assert_equal '\b', exp[1].text
-
-    assert       exp.matches?('a')
-    assert       exp.matches?("\b")
-    refute       exp.matches?('b')
-    assert       exp.matches?('c')
-  end
-
-  def test_parse_set_escape_sequence_hex
-    root = RP.parse('[a\x20c]', :any)
-    exp  = root[0]
-
-    assert_equal CharacterSet, exp.class
-    assert_equal 3, exp.count
-
-    assert_equal EscapeSequence::Hex, exp[1].class
-    assert_equal '\x20', exp[1].text
-  end
-
-  def test_parse_set_escape_sequence_codepoint
-    root = RP.parse('[a\u0640]')
-    exp  = root[0]
-
-    assert_equal CharacterSet, exp.class
-    assert_equal 2, exp.count
-
-    assert_equal EscapeSequence::Codepoint, exp[1].class
-    assert_equal '\u0640', exp[1].text
-  end
-
-  def test_parse_set_escape_sequence_codepoint_list
-    root = RP.parse('[a\u{41 1F60D}]')
-    exp  = root[0]
-
-    assert_equal CharacterSet, exp.class
-    assert_equal 2, exp.count
-
-    assert_equal EscapeSequence::CodepointList, exp[1].class
-    assert_equal '\u{41 1F60D}', exp[1].text
-  end
-
-  def test_parse_set_posix_class
-    root = RP.parse('[[:digit:][:^lower:]]+')
-    exp  = root[0]
-
-    assert_equal CharacterSet, exp.class
-    assert_equal 2, exp.count
-
-    assert_equal PosixClass, exp[0].class
-    assert_equal '[:digit:]', exp[0].text
-    assert_equal PosixClass, exp[1].class
-    assert_equal '[:^lower:]', exp[1].text
-  end
-
-  def test_parse_set_nesting
-    root = RP.parse('[a[b[c]d]e]')
-
-    exp = root[0]
-    assert_equal CharacterSet, exp.class
-    assert_equal 3, exp.count
-    assert_equal Literal, exp[0].class
-    assert_equal Literal, exp[2].class
-
-    subset1 = exp[1]
-    assert_equal CharacterSet, subset1.class
-    assert_equal 3, subset1.count
-    assert_equal Literal, subset1[0].class
-    assert_equal Literal, subset1[2].class
-
-    subset2 = subset1[1]
-    assert_equal CharacterSet, subset2.class
-    assert_equal 1, subset2.count
-    assert_equal Literal, subset2[0].class
-  end
-
-  def test_parse_set_nesting_negative
-    root = RP.parse('[a[^b[c]]]')
-    exp  = root[0]
-
-    assert_equal CharacterSet, exp.class
-    assert_equal 2, exp.count
-    assert_equal Literal, exp[0].class
-    refute       exp.negative?
-
-    subset1 = exp[1]
-    assert_equal CharacterSet, subset1.class
-    assert_equal 2, subset1.count
-    assert_equal Literal, subset1[0].class
-    assert       subset1.negative?
-
-    subset2 = subset1[1]
-    assert_equal CharacterSet, subset2.class
-    assert_equal 1, subset2.count
-    assert_equal Literal, subset2[0].class
-    refute       subset2.negative?
-  end
-
-  def test_parse_set_nesting_to_s
-    pattern = '[a[b[^c]]]'
-    root    = RP.parse(pattern)
-
-    assert_equal pattern, root.to_s
-  end
-
-  def test_parse_set_literals_are_not_merged
-    root = RP.parse("[#{'a' * 10}]")
-    exp  = root[0]
-
-    assert_equal 10, exp.count
-  end
-
-  def test_parse_set_whitespace_is_not_merged
-    root = RP.parse("[#{' ' * 10}]")
-    exp  = root[0]
-
-    assert_equal 10, exp.count
-  end
-
-  def test_parse_set_whitespace_is_not_merged_in_x_mode
-    root = RP.parse("(?x)[#{' ' * 10}]")
-    exp  = root[1]
-
-    assert_equal 10, exp.count
-  end
-
-  # TODO: Collations and equivalents need own exp class if they ever get enabled
-  def test_parse_set_collating_sequence
-    root = RP.parse('[a[.span-ll.]h]', :any)
-    exp  = root[0]
-
-    assert_equal '[.span-ll.]', exp[1].to_s
-  end
-
-  def test_parse_set_character_equivalents
-    root = RP.parse('[a[=e=]h]', :any)
-    exp  = root[0]
-
-    assert_equal '[=e=]', exp[1].to_s
-  end
-end

data/test/scanner/test_all.rb

@@ -1,38 +0,0 @@
-require File.expand_path("../../helpers", __FILE__)
-
-%w[
-  anchors errors escapes free_space groups literals meta
-  properties quantifiers refcalls scripts sets types unicode_blocks
-].each do |tc|
-  require File.expand_path("../test_#{tc}", __FILE__)
-end
-
-if RUBY_VERSION >= '2.0.0'
-  %w{conditionals keep}.each do|tc|
-    require File.expand_path("../test_#{tc}", __FILE__)
-  end
-end
-
-class TestRegexpScanner < Test::Unit::TestCase
-
-  def test_scanner_returns_an_array
-    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$')
-
-    all_arrays = tokens.all? do |token|
-      token.kind_of?(Array) and token.length == 5
-    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 28, RS.scan(re).length
-  end
-
-end

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_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

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