regexp_parser 1.4.0 → 1.7.1

data/test/parser/test_anchors.rb

@@ -1,34 +0,0 @@
-require File.expand_path("../../helpers", __FILE__)
-
-class TestParserAnchors < Test::Unit::TestCase
-
-  tests = {
-    '^a'      => [0, :anchor,   :bol,                 Anchor::BOL],
-    'a$'      => [1, :anchor,   :eol,                 Anchor::EOL],
-
-    '\Aa'     => [0, :anchor,   :bos,                 Anchor::BOS],
-    'a\z'     => [1, :anchor,   :eos,                 Anchor::EOS],
-    'a\Z'     => [1, :anchor,   :eos_ob_eol,          Anchor::EOSobEOL],
-
-    'a\b'     => [1, :anchor,   :word_boundary,       Anchor::WordBoundary],
-    'a\B'     => [1, :anchor,   :nonword_boundary,    Anchor::NonWordBoundary],
-
-    'a\G'     => [1, :anchor,   :match_start,         Anchor::MatchStart],
-
-    "\\\\Aa"  => [0, :escape,   :backslash,           EscapeSequence::Literal],
-  }
-
-  tests.each_with_index do |(pattern, (index, type, token, klass)), count|
-    define_method "test_parse_anchor_#{token}_#{count}" do
-      root = RP.parse(pattern, 'ruby/1.9')
-      exp  = root.expressions.at(index)
-
-      assert exp.is_a?(klass),
-             "Expected #{klass}, but got #{exp.class.name}"
-
-      assert_equal type,  exp.type
-      assert_equal token, exp.token
-    end
-  end
-
-end

data/test/parser/test_conditionals.rb

@@ -1,187 +0,0 @@
-require File.expand_path("../../helpers", __FILE__)
-
-class TestParserConditionals < Test::Unit::TestCase
-
-  def test_parse_conditional
-    regexp = /(?<A>a)(?(<A>)T|F)/
-
-    root = RP.parse(regexp, 'ruby/2.0')
-    exp  = root.expressions[1]
-
-    assert exp.is_a?(Conditional::Expression),
-           "Expected Condition, but got #{exp.class.name}"
-
-    assert_equal exp.type,      :conditional
-    assert_equal exp.token,     :open
-    assert_equal exp.text,      '(?'
-    assert_equal exp.reference, 'A'
-  end
-
-  def test_parse_conditional_condition
-    regexp = /(?<A>a)(?(<A>)T|F)/
-
-    root = RP.parse(regexp, 'ruby/2.0')
-    exp  = root[1].condition
-
-    assert exp.is_a?(Conditional::Condition),
-           "Expected Condition, but got #{exp.class.name}"
-
-    assert_equal exp.type,      :conditional
-    assert_equal exp.token,     :condition
-    assert_equal exp.text,      '(<A>)'
-    assert_equal exp.reference, 'A'
-  end
-
-  def test_parse_conditional_condition_with_number_ref
-    regexp = /(a)(?(1)T|F)/
-
-    root = RP.parse(regexp, 'ruby/2.0')
-    exp  = root[1].condition
-
-    assert exp.is_a?(Conditional::Condition),
-           "Expected Condition, but got #{exp.class.name}"
-
-    assert_equal exp.type,      :conditional
-    assert_equal exp.token,     :condition
-    assert_equal exp.text,      '(1)'
-    assert_equal exp.reference, 1
-  end
-
-  def test_parse_conditional_nested_groups
-    regexp = /((a)|(b)|((?(2)(c(d|e)+)?|(?(3)f|(?(4)(g|(h)(i)))))))/
-
-    root = RP.parse(regexp, 'ruby/2.0')
-
-    assert_equal regexp.source, root.to_s
-
-    group = root.first
-    assert_equal Group::Capture, group.class
-
-    alt = group.first
-    assert_equal Alternation, alt.class
-    assert_equal 3, alt.length
-
-    all_captures = alt.all? do |exp|
-      exp.first.is_a?(Group::Capture)
-    end
-
-    assert_equal true, all_captures
-
-    subgroup    = alt[2].first
-    conditional = subgroup.first
-
-    assert_equal Conditional::Expression, conditional.class
-    assert_equal 3, conditional.length
-
-    assert_equal Conditional::Condition,  conditional[0].class
-    assert_equal '(2)',                   conditional[0].text
-
-    condition = conditional.condition
-    assert_equal Conditional::Condition,  condition.class
-    assert_equal '(2)',                   condition.text
-
-    branches = conditional.branches
-    assert_equal 2,      branches.length
-    assert_equal Array,  branches.class
-  end
-
-  def test_parse_conditional_nested
-    regexp = /(a(b(c(d)(e))))(?(1)(?(2)d|(?(3)e|f))|(?(4)(?(5)g|h)))/
-
-    root = RP.parse(regexp, 'ruby/2.0')
-
-    assert_equal regexp.source, root.to_s
-
-    { 1 => [2, root[1]],
-      2 => [2, root[1][1][0]],
-      3 => [2, root[1][1][0][2][0]],
-      4 => [1, root[1][2][0]],
-      5 => [2, root[1][2][0][1][0]],
-    }.each do |index, test|
-      branch_count, exp = test
-
-      assert_equal Conditional::Expression, exp.class
-      assert_equal "(#{index})", exp.condition.text
-      assert_equal branch_count, exp.branches.length
-    end
-  end
-
-  def test_parse_conditional_nested_alternation
-    regexp = /(a)(?(1)(b|c|d)|(e|f|g))(h)(?(2)(i|j|k)|(l|m|n))|o|p/
-
-    root = RP.parse(regexp, 'ruby/2.0')
-
-    assert_equal regexp.source, root.to_s
-
-    assert_equal Alternation, root.first.class
-
-    [ [3, 'b|c|d', root[0][0][1][1][0][0]],
-      [3, 'e|f|g', root[0][0][1][2][0][0]],
-      [3, 'i|j|k', root[0][0][3][1][0][0]],
-      [3, 'l|m|n', root[0][0][3][2][0][0]],
-    ].each do |test|
-      alt_count, alt_text, exp = test
-
-      assert_equal Alternation, exp.class
-      assert_equal alt_text,    exp.to_s
-      assert_equal alt_count,   exp.alternatives.length
-    end
-  end
-
-  def test_parse_conditional_extra_separator
-    regexp = /(?<A>a)(?(<A>)T|)/
-
-    root = RP.parse(regexp, 'ruby/2.0')
-    branches = root[1].branches
-
-    assert_equal 2, branches.length
-
-    seq_1, seq_2 = branches
-
-    [seq_1, seq_2].each do |seq|
-      assert seq.is_a?( Sequence ),
-             "Expected Condition, but got #{seq.class.name}"
-
-      assert_equal :expression, seq.type
-      assert_equal :sequence,   seq.token
-    end
-
-    assert_equal 'T', seq_1.to_s
-    assert_equal '',  seq_2.to_s
-  end
-
-  def test_parse_conditional_quantified
-    regexp = /(foo)(?(1)\d|(\w)){42}/
-
-    root = RP.parse(regexp, 'ruby/2.0')
-    conditional = root[1]
-
-    assert conditional.quantified?
-    assert_equal '{42}',              conditional.quantifier.text
-    assert_equal '(?(1)\d|(\w)){42}', conditional.to_s
-    refute conditional.branches.any?(&:quantified?)
-  end
-
-  def test_parse_conditional_branch_content_quantified
-    regexp = /(foo)(?(1)\d{23}|(\w){42})/
-
-    root = RP.parse(regexp, 'ruby/2.0')
-    conditional = root[1]
-
-    refute conditional.quantified?
-    refute conditional.branches.any?(&:quantified?)
-    assert conditional.branches[0][0].quantified?
-    assert_equal '{23}', conditional.branches[0][0].quantifier.text
-    assert conditional.branches[1][0].quantified?
-    assert_equal '{42}', conditional.branches[1][0].quantifier.text
-  end
-
-  # For source (text) expressions only, ruby raises an error otherwise.
-  def test_parse_conditional_excessive_branches
-    regexp = '(?<A>a)(?(<A>)T|F|X)'
-
-    assert_raise( Conditional::TooManyBranches ) {
-      RP.parse(regexp, 'ruby/2.0')
-    }
-  end
-end

data/test/parser/test_errors.rb

@@ -1,63 +0,0 @@
-require File.expand_path("../../helpers", __FILE__)
-
-class ParserErrors < Test::Unit::TestCase
-  def setup
-    @rp = Regexp::Parser.new
-    @rp.parse(/foo/)
-  end
-
-  def test_parser_unknown_token_type
-    assert_raise( Regexp::Parser::UnknownTokenTypeError ) {
-      @rp.__send__(:parse_token, Regexp::Token.new(:foo, :bar))
-    }
-  end
-
-  def test_parser_unknown_set_token
-    assert_raise( Regexp::Parser::UnknownTokenError ) {
-      @rp.__send__(:parse_token, Regexp::Token.new(:set, :foo))
-    }
-  end
-
-  def test_parser_unknown_meta_token
-    assert_raise( Regexp::Parser::UnknownTokenError ) {
-      @rp.__send__(:parse_token, Regexp::Token.new(:meta, :foo))
-    }
-  end
-
-  def test_parser_unknown_character_type_token
-    assert_raise( Regexp::Parser::UnknownTokenError ) {
-      @rp.__send__(:parse_token, Regexp::Token.new(:type, :foo))
-    }
-  end
-
-  def test_parser_unknown_unicode_property_token
-    assert_raise( Regexp::Parser::UnknownTokenError ) {
-      @rp.__send__(:parse_token, Regexp::Token.new(:property, :foo))
-    }
-  end
-
-  def test_parser_unknown_unicode_nonproperty_token
-    assert_raise( Regexp::Parser::UnknownTokenError ) {
-      @rp.__send__(:parse_token, Regexp::Token.new(:nonproperty, :foo))
-    }
-  end
-
-  def test_parser_unknown_anchor_token
-    assert_raise( Regexp::Parser::UnknownTokenError ) {
-      @rp.__send__(:parse_token, Regexp::Token.new(:anchor, :foo))
-    }
-  end
-
-  def test_parser_unknown_quantifier_token
-    assert_raise( Regexp::Parser::UnknownTokenError ) {
-      @rp.__send__(:parse_token, Regexp::Token.new(:quantifier, :foo))
-    }
-  end
-
-  def test_parser_unknown_group_open_token
-    assert_raise( Regexp::Parser::UnknownTokenError ) {
-      @rp.__send__(:parse_token, Regexp::Token.new(:group, :foo))
-    }
-  end
-
-end

data/test/parser/test_escapes.rb

@@ -1,134 +0,0 @@
-require File.expand_path("../../helpers", __FILE__)
-
-class TestParserEscapes < Test::Unit::TestCase
-
-  tests = {
-    /a\ac/    => [1, :escape,   :bell,              EscapeSequence::Bell],
-    /a\ec/    => [1, :escape,   :escape,            EscapeSequence::AsciiEscape],
-    /a\fc/    => [1, :escape,   :form_feed,         EscapeSequence::FormFeed],
-    /a\nc/    => [1, :escape,   :newline,           EscapeSequence::Newline],
-    /a\rc/    => [1, :escape,   :carriage,          EscapeSequence::Return],
-    /a\tc/    => [1, :escape,   :tab,               EscapeSequence::Tab],
-    /a\vc/    => [1, :escape,   :vertical_tab,      EscapeSequence::VerticalTab],
-
-    # meta character escapes
-    /a\.c/    => [1, :escape,   :dot,               EscapeSequence::Literal],
-    /a\?c/    => [1, :escape,   :zero_or_one,       EscapeSequence::Literal],
-    /a\*c/    => [1, :escape,   :zero_or_more,      EscapeSequence::Literal],
-    /a\+c/    => [1, :escape,   :one_or_more,       EscapeSequence::Literal],
-    /a\|c/    => [1, :escape,   :alternation,       EscapeSequence::Literal],
-    /a\(c/    => [1, :escape,   :group_open,        EscapeSequence::Literal],
-    /a\)c/    => [1, :escape,   :group_close,       EscapeSequence::Literal],
-    /a\{c/    => [1, :escape,   :interval_open,     EscapeSequence::Literal],
-    /a\}c/    => [1, :escape,   :interval_close,    EscapeSequence::Literal],
-
-    # unicode escapes
-    /a\u0640/       => [1, :escape, :codepoint,      EscapeSequence::Codepoint],
-    /a\u{41 1F60D}/ => [1, :escape, :codepoint_list, EscapeSequence::CodepointList],
-    /a\u{10FFFF}/   => [1, :escape, :codepoint_list, EscapeSequence::CodepointList],
-
-     # hex escapes
-    /a\xFF/n =>  [1, :escape, :hex,                 EscapeSequence::Hex],
-
-    # octal escapes
-    /a\177/n =>  [1, :escape, :octal,               EscapeSequence::Octal],
-  }
-
-  tests.each_with_index do |(pattern, (index, type, token, klass)), count|
-    define_method "test_parse_escape_#{token}_#{count+=1}" do
-      root = RP.parse(pattern, 'ruby/1.9')
-      exp  = root.expressions.at(index)
-
-      assert exp.is_a?(klass),
-             "Expected #{klass}, but got #{exp.class.name}"
-
-      assert_equal type,  exp.type
-      assert_equal token, exp.token
-    end
-  end
-
-  def test_parse_chars_and_codepoints
-    root = RP.parse(/\n\?\101\x42\u0043\u{44 45}/)
-
-    assert_equal "\n",       root[0].char
-    assert_equal 10,         root[0].codepoint
-
-    assert_equal "?",        root[1].char
-    assert_equal 63,         root[1].codepoint
-
-    assert_equal "A",        root[2].char
-    assert_equal 65,         root[2].codepoint
-
-    assert_equal "B",        root[3].char
-    assert_equal 66,         root[3].codepoint
-
-    assert_equal "C",        root[4].char
-    assert_equal 67,         root[4].codepoint
-
-    assert_equal ["D", "E"], root[5].chars
-    assert_equal [68, 69],   root[5].codepoints
-  end
-
-  def test_parse_escape_control_sequence_lower
-    root = RP.parse(/a\\\c2b/)
-
-    assert_equal EscapeSequence::Control, root[2].class
-    assert_equal '\\c2',                  root[2].text
-    assert_equal "\u0012",                root[2].char
-    assert_equal 18,                      root[2].codepoint
-  end
-
-  def test_parse_escape_control_sequence_upper
-    root = RP.parse(/\d\\\C-C\w/)
-
-    assert_equal EscapeSequence::Control, root[2].class
-    assert_equal '\\C-C',                 root[2].text
-    assert_equal "\u0003",                root[2].char
-    assert_equal 3,                       root[2].codepoint
-  end
-
-  def test_parse_escape_meta_sequence
-    root = RP.parse(/\Z\\\M-Z/n)
-
-    assert_equal EscapeSequence::Meta, root[2].class
-    assert_equal '\\M-Z',              root[2].text
-    assert_equal "\u00DA",             root[2].char
-    assert_equal 218,                  root[2].codepoint
-  end
-
-  def test_parse_escape_meta_control_sequence
-    root = RP.parse(/\A\\\M-\C-X/n)
-
-    assert_equal EscapeSequence::MetaControl, root[2].class
-    assert_equal '\\M-\\C-X',                 root[2].text
-    assert_equal "\u0098",                    root[2].char
-    assert_equal 152,                         root[2].codepoint
-  end
-
-  def test_parse_lower_c_meta_control_sequence
-    root = RP.parse(/\A\\\M-\cX/n)
-
-    assert_equal EscapeSequence::MetaControl, root[2].class
-    assert_equal '\\M-\\cX',                  root[2].text
-    assert_equal "\u0098",                    root[2].char
-    assert_equal 152,                         root[2].codepoint
-  end
-
-  def test_parse_escape_reverse_meta_control_sequence
-    root = RP.parse(/\A\\\C-\M-X/n)
-
-    assert_equal EscapeSequence::MetaControl, root[2].class
-    assert_equal '\\C-\\M-X',                 root[2].text
-    assert_equal "\u0098",                    root[2].char
-    assert_equal 152,                         root[2].codepoint
-  end
-
-  def test_parse_escape_reverse_lower_c_meta_control_sequence
-    root = RP.parse(/\A\\\c\M-X/n)
-
-    assert_equal EscapeSequence::MetaControl, root[2].class
-    assert_equal '\\c\\M-X',                  root[2].text
-    assert_equal "\u0098",                    root[2].char
-    assert_equal 152,                         root[2].codepoint
-  end
-end

data/test/parser/test_free_space.rb

@@ -1,139 +0,0 @@
-require File.expand_path("../../helpers", __FILE__)
-
-class ParserFreeSpace < Test::Unit::TestCase
-
-  def test_parse_free_space_spaces
-    regexp = /a ? b * c + d{2,4}/x
-    root   = RP.parse(regexp)
-
-    0.upto(6) do |i|
-      if i.odd?
-        # Consecutive spaces get merged by the parser, thus the two spaces.
-        assert_equal WhiteSpace, root[i].class
-        assert_equal '  ',       root[i].text
-      else
-        assert_equal Literal, root[i].class
-        assert_equal true,    root[i].quantified?
-      end
-    end
-  end
-
-  def test_parse_non_free_space_literals
-    regexp = /a b c d/
-    root   = RP.parse(regexp)
-
-    assert_equal Literal,    root.first.class
-    assert_equal 'a b c d',  root.first.text
-  end
-
-  def test_parse_free_space_comments
-    regexp = %r{
-      a   ?     # One letter
-      b {2,5}   # Another one
-      [c-g]  +  # A set
-      (h|i|j) | # A group
-      klm *
-      nop +
-    }x
-
-    root = RP.parse(regexp)
-
-    alt = root.first
-    assert_equal Alternation, alt.class
-
-    alt_1 = alt.alternatives.first
-    assert_equal Alternative, alt_1.class
-    assert_equal 15, alt_1.length
-
-    [0, 2, 4, 6, 8, 12, 14].each do |i|
-      assert_equal WhiteSpace, alt_1[i].class
-    end
-
-    [3, 7, 11].each do |i|
-      assert_equal Comment, alt_1[i].class
-    end
-
-    alt_2 = alt.alternatives.last
-    assert_equal Alternative, alt_2.class
-    assert_equal 7, alt_2.length
-
-    [0, 2, 4, 6].each do |i|
-      assert_equal WhiteSpace, alt_2[i].class
-    end
-
-    assert_equal Comment, alt_2[1].class
-  end
-
-  def test_parse_free_space_nested_comments
-    # Tests depend on spacing and indentation, obviously.
-    regexp = %r{
-      # Group one
-      (
-       abc  # Comment one
-       \d?  # Optional \d
-      )+
-
-      # Group two
-      (
-       def  # Comment two
-       \s?  # Optional \s
-      )?
-    }x
-
-    root = RP.parse(regexp)
-
-    top_comment_1 = root[1]
-    assert_equal Comment,         top_comment_1.class
-    assert_equal "# Group one\n", top_comment_1.text
-    assert_equal 7,               top_comment_1.starts_at
-
-    top_comment_2 = root[5]
-    assert_equal Comment,         top_comment_2.class
-    assert_equal "# Group two\n", top_comment_2.text
-    assert_equal 95,              top_comment_2.starts_at
-
-    # Nested comments
-    [3, 7].each_with_index do |g, i|
-      group = root[g]
-
-      [3, 7].each do |c|
-        comment = group[c]
-        assert_equal Comment, comment.class
-        assert_equal 14,      comment.text.length
-      end
-    end
-  end
-
-  def test_parse_free_space_quantifiers
-    regexp = %r{
-      a
-      # comment 1
-      ?
-      (
-       b # comment 2
-       # comment 3
-       +
-      )
-      # comment 4
-      *
-    }x
-
-    root = RP.parse(regexp)
-
-    literal_1 = root[1]
-    assert_equal Literal,        literal_1.class
-    assert_equal true,           literal_1.quantified?
-    assert_equal :zero_or_one,   literal_1.quantifier.token
-
-    group = root[5]
-    assert_equal Group::Capture, group.class
-    assert_equal true,           group.quantified?
-    assert_equal :zero_or_more,  group.quantifier.token
-
-    literal_2 = group[1]
-    assert_equal Literal,        literal_2.class
-    assert_equal true,           literal_2.quantified?
-    assert_equal :one_or_more,   literal_2.quantifier.token
-  end
-
-end