regexp_parser 1.4.0 → 1.5.0

data/test/expression/test_all.rb

@@ -1,12 +0,0 @@
-require File.expand_path("../../helpers", __FILE__)
-
-%w{
-  base to_s to_h clone subexpression free_space tests
-  traverse strfregexp
-}.each do|tc|
-  require File.expand_path("../test_#{tc}", __FILE__)
-end
-
-if RUBY_VERSION >= '2.0.0'
-  require File.expand_path("../test_conditionals", __FILE__)
-end

data/test/expression/test_base.rb

@@ -1,90 +0,0 @@
-require File.expand_path("../../helpers", __FILE__)
-
-class ExpressionBase < Test::Unit::TestCase
-
-  def test_expression_to_re
-    re_text = '^a*(b([cde]+))+f?$'
-
-    re = RP.parse(re_text).to_re
-
-    assert re.is_a?(::Regexp),
-           'Not a Regexp, but should be'
-
-    assert_equal re.source, re_text
-  end
-
-  def test_expression_level
-    regexp = /^a(b(c(d)))e$/
-    root = RP.parse(regexp)
-
-    %w{^ a (b(c(d))) e $}.each_with_index do |t, i|
-      assert_equal t, root[i].to_s
-      assert_equal 0, root[i].level
-    end
-
-    assert_equal 'b', root[2][0].to_s
-    assert_equal 1,   root[2][0].level
-
-    assert_equal 'c', root[2][1][0].to_s
-    assert_equal 2,   root[2][1][0].level
-
-    assert_equal 'd', root[2][1][1][0].to_s
-    assert_equal 3,   root[2][1][1][0].level
-  end
-
-  def test_expression_terminal?
-    root = RP.parse('^a([b]+)c$')
-
-    assert_equal false, root.terminal?
-
-    assert_equal true,  root[0].terminal?
-    assert_equal true,  root[1].terminal?
-    assert_equal false, root[2].terminal?
-    assert_equal false, root[2][0].terminal?
-    assert_equal true,  root[2][0][0].terminal?
-    assert_equal true,  root[3].terminal?
-    assert_equal true,  root[4].terminal?
-  end
-
-  def test_expression_alt_terminal?
-    root = RP.parse('^(ab|cd)$')
-
-    assert_equal false, root.terminal?
-
-    assert_equal true,  root[0].terminal?
-    assert_equal false, root[1].terminal?
-    assert_equal false, root[1][0].terminal?
-    assert_equal false, root[1][0][0].terminal?
-    assert_equal true,  root[1][0][0][0].terminal?
-    assert_equal false, root[1][0][1].terminal?
-    assert_equal true,  root[1][0][1][0].terminal?
-  end
-
-  def test_expression_coded_offset
-    root = RP.parse('^a*(b+(c?))$')
-
-    assert_equal '@0+12', root.coded_offset
-
-    # All top level offsets
-    [
-      [ '@0+1', '^'         ],
-      [ '@1+2', 'a*'        ],
-      [ '@3+8', '(b+(c?))'  ],
-      ['@11+1', '$'         ],
-    ].each_with_index do |check, i|
-      against = [ root[i].coded_offset, root[i].to_s ]
-
-      assert_equal check, against
-    end
-
-    # Nested expression
-    assert_equal ['@4+2', 'b+'], [root[2][0].coded_offset, root[2][0].to_s]
-
-    # Nested subexpression
-    assert_equal ['@6+4', '(c?)'], [root[2][1].coded_offset, root[2][1].to_s]
-
-    # Nested subexpression expression
-    assert_equal ['@7+2', 'c?'], [root[2][1][0].coded_offset, root[2][1][0].to_s]
-  end
-
-end

data/test/expression/test_clone.rb

@@ -1,89 +0,0 @@
-require File.expand_path("../../helpers", __FILE__)
-
-class ExpressionClone < Test::Unit::TestCase
-
-  def test_expression_clone_base
-    root = RP.parse(/^(?i:a)b+$/i)
-    copy = root.clone
-
-    refute_equal copy.object_id, root.object_id
-
-    # The text content is equal but the objects are not.
-    assert_equal copy.text,           root.text
-    refute_equal copy.text.object_id, root.text.object_id
-
-    root_1 = root.expressions[1]
-    copy_1 = copy.expressions[1]
-
-    # The options hash contents are equal but the objects are not.
-    assert_equal copy_1.options,           root_1.options
-    refute_equal copy_1.options.object_id, root_1.options.object_id
-
-    root_2 = root.expressions[2]
-    copy_2 = copy.expressions[2]
-
-    assert root_2.quantified?
-    assert copy_2.quantified?
-
-    # The quantifier contents are equal but the objects are not.
-    assert_equal copy_2.quantifier.text,
-                 root_2.quantifier.text
-
-    refute_equal copy_2.quantifier.text.object_id,
-                 root_2.quantifier.text.object_id
-
-    refute_equal copy_2.quantifier.object_id,
-                 root_2.quantifier.object_id
-  end
-
-  def test_expression_clone_subexpression
-    root = RP.parse(/^a(b([cde])f)g$/)
-    copy = root.clone
-
-    assert root.respond_to?(:expressions)
-    assert copy.respond_to?(:expressions)
-
-    # The expressions arrays are not equal.
-    refute_equal copy.expressions.object_id,
-                 root.expressions.object_id
-
-    # The expressions in the arrays are not equal.
-    copy.expressions.each_with_index do |exp, index|
-      refute_equal exp.object_id,
-                   root.expressions[index].object_id
-    end
-
-    # The expressions in nested expressions are not equal.
-    copy.expressions[2].each_with_index do |exp, index|
-      refute_equal exp.object_id,
-                   root.expressions[2][index].object_id
-    end
-  end
-
-  # ruby 1.8 does not implement named groups
-  def test_expression_clone_named_group
-    root = RP.parse('^(?<somename>a)+bc$')
-    copy = root.clone
-
-    root_1 = root.expressions[1]
-    copy_1 = copy.expressions[1]
-
-    # The names are equal but their objects are not.
-    assert_equal copy_1.name,           root_1.name
-    refute_equal copy_1.name.object_id, root_1.name.object_id
-
-    # Verify super: text objects should be different.
-    assert_equal copy_1.text, root_1.text
-
-    # Verify super: expressions arrays are not equal.
-    refute_equal copy_1.expressions.object_id,
-                 root_1.expressions.object_id
-
-    # Verify super: expressions in the arrays are not equal.
-    copy_1.expressions.each_with_index do |exp, index|
-      refute_equal exp.object_id,
-                   root_1.expressions[index].object_id
-    end
-  end
-
-end

data/test/expression/test_conditionals.rb

@@ -1,113 +0,0 @@
-require File.expand_path("../../helpers", __FILE__)
-
-class ExpressionConditionals < Test::Unit::TestCase
-
-  def setup
-    @root = RP.parse(/^(a(b))(b(?(1)c|(?(2)d|(?(3)e|f)))g)$/)
-
-    @cond_1 = @root[2][1]
-    @cond_2 = @root[2][1][2][0]
-    @cond_3 = @root[2][1][2][0][2][0]
-  end
-
-  def is_conditional_condition?(exp)
-    exp.is_a?(Conditional::Condition)
-  end
-
-  def is_conditional_branch?(exp)
-    exp.is_a?(Conditional::Branch)
-  end
-
-  def test_expression_conditional_root_level
-    %w{^ (a(b)) (b(?(1)c|(?(2)d|(?(3)e|f)))g) $}.each_with_index do |t, i|
-      assert_equal 0, @root[i].conditional_level
-      assert_equal t, @root[i].to_s
-    end
-
-    # First capture group
-    assert_equal 'b', @root[2][0].text
-    assert_equal 0,   @root[2][0].conditional_level
-  end
-
-  def test_expression_conditional_level_one
-    condition = @cond_1.condition
-    branch_1  = @cond_1.branches.first
-
-    # Condition
-    assert_equal true,  is_conditional_condition?(condition)
-    assert_equal '(1)', condition.text
-    assert_equal 1,     condition.conditional_level
-
-    # Branch 1
-    assert_equal true,  is_conditional_branch?(branch_1)
-    assert_equal 'c',   branch_1.text
-    assert_equal 1,     branch_1.conditional_level
-
-    # Literal
-    assert_equal 'c',   branch_1.first.text
-    assert_equal 1,     branch_1.first.conditional_level
-
-  end
-
-  def test_expression_conditional_level_two
-    condition = @cond_2.condition
-    branch_1  = @cond_2.branches.first
-    branch_2  = @cond_2.branches.last
-
-    assert_equal '(?',   @cond_2.text
-    assert_equal 1,      @cond_2.conditional_level
-
-    # Condition
-    assert_equal true,   is_conditional_condition?(condition)
-    assert_equal '(2)',  condition.text
-    assert_equal 2,      condition.conditional_level
-
-    # Branch 1
-    assert_equal true,   is_conditional_branch?(branch_1)
-    assert_equal 'd',    branch_1.text
-    assert_equal 2,      branch_1.conditional_level
-
-    # Literal
-    assert_equal 'd',    branch_1.first.text
-    assert_equal 2,      branch_1.first.conditional_level
-
-    # Branch 2
-    assert_equal '(?',   branch_2.first.text
-    assert_equal 2,      branch_2.first.conditional_level
-  end
-
-  def test_expression_conditional_level_three
-    condition = @cond_3.condition
-    branch_1  = @cond_3.branches.first
-    branch_2  = @cond_3.branches.last
-
-    # Condition
-    assert_equal true,   is_conditional_condition?(condition)
-    assert_equal '(3)',  condition.text
-    assert_equal 3,      condition.conditional_level
-
-    # Same as branch 2 in level two
-    assert_equal '(?',         @cond_3.text
-    assert_equal '(?(3)e|f)',  @cond_3.to_s
-    assert_equal 2,            @cond_3.conditional_level
-
-    # Branch 1
-    assert_equal true,   is_conditional_branch?(branch_1)
-    assert_equal 'e',    branch_1.text
-    assert_equal 3,      branch_1.conditional_level
-
-    # Literal
-    assert_equal 'e',    branch_1.first.text
-    assert_equal 3,      branch_1.first.conditional_level
-
-    # Branch 2
-    assert_equal true,   is_conditional_branch?(branch_2)
-    assert_equal 'f',    branch_2.text
-    assert_equal 3,      branch_2.conditional_level
-
-    # Literal
-    assert_equal 'f',    branch_2.first.text
-    assert_equal 3,      branch_2.first.conditional_level
-  end
-
-end

data/test/expression/test_free_space.rb

@@ -1,35 +0,0 @@
-require File.expand_path("../../helpers", __FILE__)
-
-class ExpressionFreeSpace < Test::Unit::TestCase
-
-  def test_expression_white_space_quantify_raises_error
-    regexp = %r{
-      a # Comment
-    }x
-
-    root = RP.parse(regexp)
-
-    space = root[0]
-    assert_equal FreeSpace::WhiteSpace, space.class
-
-    assert_raise( RuntimeError ) {
-      space.quantify(:dummy, '#')
-    }
-  end
-
-  def test_expression_comment_quantify_raises_error
-    regexp = %r{
-      a # Comment
-    }x
-
-    root = RP.parse(regexp)
-
-    comment = root[3]
-    assert_equal FreeSpace::Comment, comment.class
-
-    assert_raise( RuntimeError ) {
-      comment.quantify(:dummy, '#')
-    }
-  end
-
-end

data/test/expression/test_set.rb

@@ -1,84 +0,0 @@
-require File.expand_path("../../helpers", __FILE__)
-
-class ExpressionSet < Test::Unit::TestCase
-
-  def test_expression_set_expand_members_digit
-    set = RP.parse('[\d]').first
-
-    assert_equal ['0-9'],       set.expand_members
-    assert_equal ['\p{Digit}'], set.expand_members(true)
-  end
-
-  def test_expression_set_expand_members_nondigit
-    set = RP.parse('[\D]').first
-
-    assert_equal ['^0-9'],      set.expand_members
-    assert_equal ['\P{Digit}'], set.expand_members(true)
-  end
-
-  def test_expression_set_expand_members_word
-    set = RP.parse('[\w]').first
-
-    assert_equal ['A-Za-z0-9_'], set.expand_members
-    assert_equal ['\p{Word}'],   set.expand_members(true)
-  end
-
-  def test_expression_set_expand_members_nonword
-    set = RP.parse('[\W]').first
-
-    assert_equal ['^A-Za-z0-9_'], set.expand_members
-    assert_equal ['\P{Word}'],    set.expand_members(true)
-  end
-
-  def test_expression_set_expand_members_space
-    set = RP.parse('[\s]').first
-
-    assert_equal [' \t\f\v\n\r'], set.expand_members
-    assert_equal ['\p{Space}'],   set.expand_members(true)
-  end
-
-  def test_expression_set_expand_members_nonspace
-    set = RP.parse('[\S]').first
-
-    assert_equal ['^ \t\f\v\n\r'], set.expand_members
-    assert_equal ['\P{Space}'],    set.expand_members(true)
-  end
-
-  def test_expression_set_expand_members_xdigit
-    set = RP.parse('[\h]').first
-
-    assert_equal ['0-9A-Fa-f'],  set.expand_members
-    assert_equal ['\p{Xdigit}'], set.expand_members(true)
-  end
-
-  def test_expression_set_expand_members_nonxdigit
-    set = RP.parse('[\H]').first
-
-    assert_equal ['^0-9A-Fa-f'], set.expand_members
-    assert_equal ['\P{Xdigit}'], set.expand_members(true)
-  end
-
-  def test_expression_set_include
-    set = RP.parse('[ac-eh\s[:digit:]\x20[b]]').first
-
-    assert set.include?('a')
-    assert set.include?('a', true)
-    assert set.include?('c-e')
-    assert set.include?('h')
-    assert set.include?('\s')
-    assert set.include?('[:digit:]')
-    assert set.include?('\x20')
-
-    assert set.include?('b')
-    refute set.include?('b', true) # should not include b directly
-
-    refute set.include?(']')
-    refute set.include?('[')
-    refute set.include?('x')
-    refute set.include?('\S')
-
-    subset = set.last
-    assert subset.include?('b')
-    refute subset.include?('a')
-  end
-end

data/test/expression/test_strfregexp.rb

@@ -1,230 +0,0 @@
-require File.expand_path("../../helpers", __FILE__)
-
-class Expressionstrfregexp < Test::Unit::TestCase
-
-  def test_expression_strfre_alias
-    assert_equal true, RP.parse(/a/).respond_to?(:strfre)
-  end
-
-  def test_expression_strfregexp_level
-    root = RP.parse(/a(b(c))/)
-
-    assert_equal 'root', root.strfregexp('%l')
-
-    a = root.first
-    assert_equal '%0', a.strfregexp('%%l')
-
-    b = root[1].first
-    assert_equal '<1>', b.strfregexp('<%l>')
-
-    c = root[1][1].first
-    assert_equal '[at: 2]', c.strfregexp('[at: %l]')
-  end
-
-  def test_expression_strfregexp_start_end
-    root = RP.parse(/a(b(c))/)
-
-    assert_equal '0', root.strfregexp('%s')
-    assert_equal '7', root.strfregexp('%e')
-
-    a = root.first
-    assert_equal '%0', a.strfregexp('%%s')
-    assert_equal '1', a.strfregexp('%e')
-
-    group_1 = root[1]
-    assert_equal 'GRP:1', group_1.strfregexp('GRP:%s')
-    assert_equal '7', group_1.strfregexp('%e')
-
-    b = group_1.first
-    assert_equal '<@2>', b.strfregexp('<@%s>')
-    assert_equal '3', b.strfregexp('%e')
-
-    c = group_1.last.first
-    assert_equal '[at: 4]',  c.strfregexp('[at: %s]')
-    assert_equal '5', c.strfregexp('%e')
-  end
-
-  def test_expression_strfregexp_length
-    root = RP.parse(/a[b]c/)
-
-    assert_equal '5', root.strfregexp('%S')
-
-    a = root.first
-    assert_equal '1', a.strfregexp('%S')
-
-    set = root[1]
-    assert_equal '3', set.strfregexp('%S')
-  end
-
-  def test_expression_strfregexp_coded_offset
-    root = RP.parse(/a[b]c/)
-
-    assert_equal '@0+5', root.strfregexp('%o')
-
-    a = root.first
-    assert_equal '@0+1', a.strfregexp('%o')
-
-    set = root[1]
-    assert_equal '@1+3', set.strfregexp('%o')
-  end
-
-  def test_expression_strfregexp_type_token
-    root = RP.parse(/a[b](c)/)
-
-    assert_equal 'expression', root.strfregexp('%y')
-    assert_equal 'root', root.strfregexp('%k')
-    assert_equal 'expression:root', root.strfregexp('%i')
-    assert_equal 'Regexp::Expression::Root', root.strfregexp('%c')
-
-    a = root.first
-    assert_equal 'literal', a.strfregexp('%y')
-    assert_equal 'literal', a.strfregexp('%k')
-    assert_equal 'literal:literal', a.strfregexp('%i')
-    assert_equal 'Regexp::Expression::Literal', a.strfregexp('%c')
-
-    set = root[1]
-    assert_equal 'set', set.strfregexp('%y')
-    assert_equal 'character', set.strfregexp('%k')
-    assert_equal 'set:character', set.strfregexp('%i')
-    assert_equal 'Regexp::Expression::CharacterSet', set.strfregexp('%c')
-
-    group = root.last
-    assert_equal 'group', group.strfregexp('%y')
-    assert_equal 'capture', group.strfregexp('%k')
-    assert_equal 'group:capture', group.strfregexp('%i')
-    assert_equal 'Regexp::Expression::Group::Capture', group.strfregexp('%c')
-  end
-
-  def test_expression_strfregexp_quantifier
-    root = RP.parse(/a+[b](c)?d{3,4}/)
-
-    assert_equal '{1}', root.strfregexp('%q')
-    assert_equal '', root.strfregexp('%Q')
-    assert_equal '1, 1', root.strfregexp('%z, %Z')
-
-    a = root.first
-    assert_equal '{1, or-more}', a.strfregexp('%q')
-    assert_equal '+', a.strfregexp('%Q')
-    assert_equal '1, -1', a.strfregexp('%z, %Z')
-
-    set = root[1]
-    assert_equal '{1}', set.strfregexp('%q')
-    assert_equal '', set.strfregexp('%Q')
-    assert_equal '1, 1', set.strfregexp('%z, %Z')
-
-    group = root[2]
-    assert_equal '{0, 1}', group.strfregexp('%q')
-    assert_equal '?', group.strfregexp('%Q')
-    assert_equal '0, 1', group.strfregexp('%z, %Z')
-
-    d = root.last
-    assert_equal '{3, 4}', d.strfregexp('%q')
-    assert_equal '{3,4}', d.strfregexp('%Q')
-    assert_equal '3, 4', d.strfregexp('%z, %Z')
-  end
-
-  def test_expression_strfregexp_text
-    root = RP.parse(/a(b(c))|[d-gk-p]+/)
-
-    assert_equal 'a(b(c))|[d-gk-p]+', root.strfregexp('%t')
-    assert_equal 'expression:root', root.strfregexp('%~t')
-
-    alt = root.first
-    assert_equal 'a(b(c))|[d-gk-p]+', alt.strfregexp('%t')
-    assert_equal 'a(b(c))|[d-gk-p]+', alt.strfregexp('%T')
-    assert_equal 'meta:alternation', alt.strfregexp('%~t')
-
-    seq_1 = alt.first
-    assert_equal 'a(b(c))', seq_1.strfregexp('%t')
-    assert_equal 'a(b(c))', seq_1.strfregexp('%T')
-    assert_equal 'expression:sequence', seq_1.strfregexp('%~t')
-
-    group = seq_1[1]
-    assert_equal '(b(c))', group.strfregexp('%t')
-    assert_equal '(b(c))', group.strfregexp('%T')
-    assert_equal 'group:capture', group.strfregexp('%~t')
-
-    seq_2 = alt.last
-    assert_equal '[d-gk-p]+', seq_2.strfregexp('%t')
-    assert_equal '[d-gk-p]+', seq_2.strfregexp('%T')
-
-    set = seq_2.first
-    assert_equal '[d-gk-p]', set.strfregexp('%t')
-    assert_equal '[d-gk-p]+', set.strfregexp('%T')
-    assert_equal 'set:character', set.strfregexp('%~t')
-  end
-
-  def test_expression_strfregexp_combined
-    root = RP.parse(/a{5}|[b-d]+/)
-
-    assert_equal '@0+11 expression:root', root.strfregexp('%b')
-    assert_equal root.strfregexp('%o %i'), root.strfregexp('%b')
-
-    assert_equal '@0+11 expression:root {1}', root.strfregexp('%m')
-    assert_equal root.strfregexp('%b %q'), root.strfregexp('%m')
-
-    assert_equal '@0+11 expression:root {1} a{5}|[b-d]+', root.strfregexp('%a')
-    assert_equal root.strfregexp('%m %t'), root.strfregexp('%a')
-  end
-
-  # regression test
-  def test_expression_strfregexp_conditional
-    root = RP.parse('(?<A>a)(?(<A>)b|c)', 'ruby/2.0')
-
-    assert_nothing_raised { root.strfregexp }
-  end
-
-  def test_expression_strfregexp_tree
-    root = RP.parse(/a[b-d]*(e(f+))?/)
-
-    assert_equal(
-      "@0+15 expression:root\n" +
-      "  @0+1 a\n" +
-      "  @1+6 set:character\n" +
-      "    @2+3 set:range\n" +
-      "      @2+1 b\n" +
-      "      @4+1 d\n" +
-      "  @7+8 group:capture\n" +
-      "    @8+1 e\n" +
-      "    @9+4 group:capture\n" +
-      "      @10+2 f+",
-      root.strfregexp_tree('%>%o %~t')
-    )
-  end
-
-  def test_expression_strfregexp_tree_separator
-    root = RP.parse(/a[b-d]*(e(f+))?/)
-
-    assert_equal(
-      "@0+15 expression:root-SEP-" +
-      "  @0+1 a-SEP-" +
-      "  @1+6 set:character-SEP-" +
-      "    @2+3 set:range-SEP-" +
-      "      @2+1 b-SEP-" +
-      "      @4+1 d-SEP-" +
-      "  @7+8 group:capture-SEP-" +
-      "    @8+1 e-SEP-" +
-      "    @9+4 group:capture-SEP-" +
-      "      @10+2 f+",
-      root.strfregexp_tree('%>%o %~t', true, '-SEP-')
-    )
-  end
-
-  def test_expression_strfregexp_tree_exclude_self
-    root = RP.parse(/a[b-d]*(e(f+))?/)
-
-    assert_equal(
-      "@0+1 a\n" +
-      "@1+6 set:character\n" +
-      "  @2+3 set:range\n" +
-      "    @2+1 b\n" +
-      "    @4+1 d\n" +
-      "@7+8 group:capture\n" +
-      "  @8+1 e\n" +
-      "  @9+4 group:capture\n" +
-      "    @10+2 f+",
-      root.strfregexp_tree('%>%o %~t', false)
-    )
-  end
-
-end