regexp_parser 0.1.6 → 0.2.0

data/test/expression/test_free_space.rb

@@ -0,0 +1,33 @@
+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

@@ -0,0 +1,61 @@
+require File.expand_path("../../helpers", __FILE__)
+
+class ExpressionSet < Test::Unit::TestCase
+
+  def test_expression_set_exapnd_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_exapnd_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_exapnd_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_exapnd_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_exapnd_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_exapnd_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_exapnd_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_exapnd_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
+
+end

data/test/expression/test_strfregexp.rb

@@ -0,0 +1,214 @@
+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( '[d-gk-p]+', 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
+
+  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 [b-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 [b-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 [b-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

data/test/expression/test_subexpression.rb

@@ -0,0 +1,24 @@
+require File.expand_path("../../helpers", __FILE__)
+
+class ExpressionSubexpression < Test::Unit::TestCase
+
+  def test_subexpression_ts_te
+    regx = /abcd|ghij|klmn|pqur/
+    root = RP.parse(regx)
+
+    alt = root.first
+
+    {
+      0 => [  0,  4 ],
+      1 => [  5,  9 ],
+      2 => [ 10, 14 ],
+      3 => [ 15, 19 ],
+    }.each do |index, span|
+      sequence = alt[index]
+
+      assert_equal( span[0], sequence.ts )
+      assert_equal( span[1], sequence.te )
+    end
+  end
+
+end

data/test/expression/test_tests.rb

@@ -0,0 +1,99 @@
+require File.expand_path("../../helpers", __FILE__)
+
+class ExpressionTests < Test::Unit::TestCase
+
+  def test_expression_type?
+    root = RP.parse(/abcd|(ghij)|[klmn]/)
+
+    alt = root.first
+
+    assert_equal( true,  alt.type?(:meta) )
+    assert_equal( false, alt.type?(:escape) )
+    assert_equal( true,  alt.type?([:meta, :escape]) )
+    assert_equal( false, alt.type?([:literal, :escape]) )
+    assert_equal( true,  alt.type?(:*) )
+    assert_equal( true,  alt.type?([:*]) )
+    assert_equal( true,  alt.type?([:literal, :escape, :*]) )
+
+    seq_1 = alt[0]
+    assert_equal( true,  seq_1.type?(:expression) )
+    assert_equal( true,  seq_1.first.type?(:literal) )
+
+    seq_2 = alt[1]
+    assert_equal( true,  seq_2.type?(:*) )
+    assert_equal( true,  seq_2.first.type?(:group) )
+
+    seq_3 = alt[2]
+    assert_equal( true,  seq_3.first.type?(:set) )
+  end
+
+  def test_expression_is?
+    root = RP.parse(/.+|\.?/)
+
+    assert_equal( true,  root.is?(:*) )
+
+    alt = root.first
+    assert_equal( true,  alt.is?(:*) )
+    assert_equal( true,  alt.is?(:alternation) )
+    assert_equal( true,  alt.is?(:alternation, :meta) )
+
+    seq_1 = alt[0]
+    assert_equal( true,  seq_1.is?(:sequence) )
+    assert_equal( true,  seq_1.is?(:sequence, :expression) )
+
+    assert_equal( true,  seq_1.first.is?(:dot) )
+    assert_equal( false, seq_1.first.is?(:dot, :escape) )
+    assert_equal( true,  seq_1.first.is?(:dot, :meta) )
+    assert_equal( true,  seq_1.first.is?(:dot, [:escape, :meta]) )
+
+    seq_2 = alt[1]
+    assert_equal( true,  seq_2.first.is?(:dot) )
+    assert_equal( true,  seq_2.first.is?(:dot, :escape) )
+    assert_equal( false, seq_2.first.is?(:dot, :meta) )
+    assert_equal( true,  seq_2.first.is?(:dot, [:meta, :escape]) )
+  end
+
+  def test_expression_one_of?
+    root = RP.parse(/\Aab(c[\w])d|e.\z/)
+
+    assert_equal( true,  root.one_of?(:*) )
+    assert_equal( true,  root.one_of?(:* => :*) )
+    assert_equal( true,  root.one_of?(:* => [:*]) )
+
+    alt = root.first
+    assert_equal( true,  alt.one_of?(:*) )
+    assert_equal( true,  alt.one_of?(:meta) )
+    assert_equal( true,  alt.one_of?(:meta, :alternation) )
+    assert_equal( false, alt.one_of?(:meta => [:dot, :bogus]) )
+    assert_equal( true,  alt.one_of?(:meta => [:dot, :alternation]) )
+
+    seq_1 = alt[0]
+    assert_equal( true,  seq_1.one_of?(:expression) )
+    assert_equal( true,  seq_1.one_of?(:expression => :sequence) )
+
+    assert_equal( true,  seq_1.first.one_of?(:anchor) )
+    assert_equal( true,  seq_1.first.one_of?(:anchor => :bos) )
+    assert_equal( false, seq_1.first.one_of?(:anchor => :eos) )
+    assert_equal( true,  seq_1.first.one_of?(:anchor => [:escape, :meta, :bos]) )
+    assert_equal( false, seq_1.first.one_of?(:anchor => [:escape, :meta, :eos]) )
+
+    seq_2 = alt[1]
+    assert_equal( true,  seq_2.first.one_of?(:literal) )
+
+    assert_equal( true,  seq_2[1].one_of?(:meta) )
+    assert_equal( true,  seq_2[1].one_of?(:meta => :dot) )
+    assert_equal( false, seq_2[1].one_of?(:meta => :alternation) )
+    assert_equal( true,  seq_2[1].one_of?(:meta => [:dot]) )
+
+    assert_equal( false, seq_2.last.one_of?(:group) )
+    assert_equal( false, seq_2.last.one_of?(:group => [:*]) )
+    assert_equal( false, seq_2.last.one_of?(:group => [:*], :meta => :*) )
+
+    assert_equal( true,  seq_2.last.one_of?(:meta => [:*], :* => :*) )
+    assert_equal( true,  seq_2.last.one_of?(:meta => [:*], :anchor => :*) )
+    assert_equal( true,  seq_2.last.one_of?(:meta => [:*], :anchor => :eos) )
+    assert_equal( false, seq_2.last.one_of?(:meta => [:*], :anchor => [:bos]) )
+    assert_equal( true,  seq_2.last.one_of?(:meta => [:*], :anchor => [:bos, :eos]) )
+  end
+
+end

data/test/expression/test_to_h.rb

@@ -0,0 +1,48 @@
+require File.expand_path("../../helpers", __FILE__)
+
+class ExpressionToH < Test::Unit::TestCase
+
+  def test_expression_to_h
+    h = RP.parse('abc').to_h
+
+    assert_equal( h, {
+      :token             => :root,
+      :type              => :expression,
+      :text              => 'abc',
+      :starts_at         => 0,
+      :length            => 3,
+      :quantifier        => nil,
+      :options           => nil,
+      :level             => nil,
+      :set_level         => nil,
+      :conditional_level => nil,
+      :expressions       => [
+        {
+          :token             => :literal,
+          :type              => :literal,
+          :text              => 'abc',
+          :starts_at         => 0,
+          :length            => 3,
+          :quantifier        => nil,
+          :options           => nil,
+          :level             => 0,
+          :set_level         => 0,
+          :conditional_level => 0
+        }
+      ]
+    })
+  end
+
+  def test_expression_quantifier_to_h
+    h = RP.parse('a{2,4}')[0].quantifier.to_h
+
+    assert_equal( h, {
+      :max   => 4,
+      :min   => 2,
+      :mode  => :greedy,
+      :text  => '{2,4}',
+      :token => :interval
+    })
+  end
+
+end