regexp_parser 0.3.4 → 0.3.5

data/test/lexer/test_nesting.rb

@@ -92,15 +92,22 @@ class LexerNesting < Test::Unit::TestCase
     },
   }
 
-  count = 0
-  tests.each do |pattern, checks|
-    define_method "test_lex_nesting_#{count+=1}" do
-
+  tests.each_with_index do |(pattern, checks), count|
+    define_method "test_lex_nesting_#{count}" do
       tokens = RL.lex(pattern, 'ruby/1.9')
-      checks.each do |offset, token|
-        assert_equal( token, tokens[offset].to_a )
-      end
 
+      checks.each do |offset, (type, token, text, ts, te, level, set_level, conditional_level)|
+        struct = tokens.at(offset)
+
+        assert_equal type,              struct.type
+        assert_equal token,             struct.token
+        assert_equal text,              struct.text
+        assert_equal ts,                struct.ts
+        assert_equal te,                struct.te
+        assert_equal level,             struct.level
+        assert_equal set_level,         struct.set_level
+        assert_equal conditional_level, struct.conditional_level
+      end
     end
   end
 

data/test/lexer/test_refcalls.rb

@@ -31,12 +31,19 @@ class LexerRefCalls < Test::Unit::TestCase
     "(abc)\\k'1-0'"     => [3, :backref, :number_nest_ref,  "\\k'1-0'",   5, 12, 0, 0, 0],
   }
 
-  count = 0
-  tests.each do |pattern, test|
-    define_method "test_lexer_#{test[1]}_#{test[2]}_#{count+=1}" do
-
+  tests.each_with_index do |(pattern, (index, type, token, text, ts, te, level, set_level, conditional_level)), count|
+    define_method "test_lexer_#{type}_#{token}_#{count}" do
       tokens = RL.lex(pattern, 'ruby/1.9')
-      assert_equal( test[1,8], tokens[test[0]].to_a)
+      struct = tokens.at(index)
+
+      assert_equal type,              struct.type
+      assert_equal token,             struct.token
+      assert_equal text,              struct.text
+      assert_equal ts,                struct.ts
+      assert_equal te,                struct.te
+      assert_equal level,             struct.level
+      assert_equal set_level,         struct.set_level
+      assert_equal conditional_level, struct.conditional_level
     end
   end
 

data/test/parser/test_all.rb

@@ -16,36 +16,38 @@ end
 class TestParser < Test::Unit::TestCase
 
   def test_parse_returns_a_root_expression
-    assert_instance_of( Regexp::Expression::Root, RP.parse('abc'))
+    assert_instance_of Regexp::Expression::Root, RP.parse('abc')
   end
 
 
   def test_parse_root_contains_expressions
     root = RP.parse(/^a.c+[^one]{2,3}\b\d\\\C-C$/)
 
-    assert( root.expressions.all?{|exp|
-      exp.kind_of?(Regexp::Expression::Base)},
-      "Not all nodes are instances of Regexp::Expression")
+    all_base = root.expressions.all? do |exp|
+      exp.kind_of?(Regexp::Expression::Base)
+    end
+
+    assert all_base, "Not all nodes are instances of Regexp::Expression"
   end
 
 
   def test_parse_node_types
     root = RP.parse('^(one){2,3}([^d\]efm-qz\,\-]*)(ghi)+$')
 
-    assert( root.expressions[1].expressions[0].is_a?(Literal),
-          "Not a literal node, but should be")
+    assert root.expressions[1].expressions[0].is_a?(Literal),
+          "Not a literal node, but should be"
 
-    assert( root.expressions[1].quantified?, "Not quanfified, but should be")
+    assert root.expressions[1].quantified?, "Not quanfified, but should be"
 
-    assert( root.expressions[2].expressions[0].is_a?(CharacterSet),
-          "Not a caracter set, but it should be")
+    assert root.expressions[2].expressions[0].is_a?(CharacterSet),
+          "Not a caracter set, but it should be"
 
-    assert_equal( false, root.expressions[2].quantified? )
+    assert_equal false, root.expressions[2].quantified?
 
-    assert( root.expressions[3].is_a?(Group::Capture),
-          "Not a group, but should be")
+    assert root.expressions[3].is_a?(Group::Capture),
+          "Not a group, but should be"
 
-    assert_equal( true, root.expressions[3].quantified? )
+    assert_equal true, root.expressions[3].quantified?
   end
 
   def test_parse_no_quantifier_target_raises_error

data/test/parser/test_alternation.rb

@@ -8,43 +8,43 @@ class ParserAlternation < Test::Unit::TestCase
 
   def test_parse_alternation_root
     e = @root.expressions[0]
-    assert_equal( true,   e.is_a?(Alternation) )
+    assert_equal true,   e.is_a?(Alternation)
   end
 
   def test_parse_alternation_alts
     alts = @root.expressions[0].alternatives
 
-    assert_equal( true,   alts[0].is_a?(Alternative) )
-    assert_equal( true,   alts[1].is_a?(Alternative) )
+    assert_equal true,   alts[0].is_a?(Alternative)
+    assert_equal true,   alts[1].is_a?(Alternative)
 
-    assert_equal( true,   alts[0][0].is_a?(Group::Capture) )
-    assert_equal( true,   alts[1][0].is_a?(Group::Capture) )
+    assert_equal true,   alts[0][0].is_a?(Group::Capture)
+    assert_equal true,   alts[1][0].is_a?(Group::Capture)
 
-    assert_equal( 2,      alts.length )
+    assert_equal 2,      alts.length
   end
 
   def test_parse_alternation_nested
     e = @root[0].alternatives[0][0][0]
 
-    assert_equal( true,   e.is_a?(Alternation) )
+    assert_equal true, e.is_a?(Alternation)
   end
 
   def test_parse_alternation_nested_sequence
     alts    = @root.expressions[0][0]
     nested  = alts.expressions[0][0][0]
 
-    assert_equal( true,   nested.is_a?(Alternative) )
+    assert_equal true,   nested.is_a?(Alternative)
 
-    assert_equal( true,   nested.expressions[0].is_a?(Literal) )
-    assert_equal( true,   nested.expressions[1].is_a?(Literal) )
-    assert_equal( 2,      nested.expressions.length )
+    assert_equal true,   nested.expressions[0].is_a?(Literal)
+    assert_equal true,   nested.expressions[1].is_a?(Literal)
+    assert_equal 2,      nested.expressions.length
   end
 
   def test_parse_alternation_nested_groups
     root = RP.parse('(i|ey|([ougfd]+)|(ney))')
 
     alts = root.expressions[0][0].alternatives
-    assert_equal( 4,  alts.length )
+    assert_equal 4,  alts.length
   end
 
   def test_parse_alternation_grouped_alts
@@ -52,11 +52,12 @@ class ParserAlternation < Test::Unit::TestCase
 
     alts = root.expressions[1][0].alternatives
 
-    assert_equal( 4,  alts.length )
-    assert_equal( true,   alts[0].is_a?(Alternative) )
-    assert_equal( true,   alts[1].is_a?(Alternative) )
-    assert_equal( true,   alts[2].is_a?(Alternative) )
-    assert_equal( true,   alts[3].is_a?(Alternative) )
+    assert_equal 4, alts.length
+
+    assert_equal true, alts[0].is_a?(Alternative)
+    assert_equal true, alts[1].is_a?(Alternative)
+    assert_equal true, alts[2].is_a?(Alternative)
+    assert_equal true, alts[3].is_a?(Alternative)
   end
 
   def test_parse_alternation_nested_grouped_alts
@@ -64,15 +65,17 @@ class ParserAlternation < Test::Unit::TestCase
 
     alts = root.expressions[1][0].alternatives
 
-    assert_equal( 2,  alts.length )
-    assert_equal( true,   alts[0].is_a?(Alternative) )
-    assert_equal( true,   alts[1].is_a?(Alternative) )
+    assert_equal 2, alts.length
+
+    assert_equal true, alts[0].is_a?(Alternative)
+    assert_equal true, alts[1].is_a?(Alternative)
 
     subalts = root.expressions[1][0][0][0][0].alternatives
 
-    assert_equal( 2,  alts.length )
-    assert_equal( true,   subalts[0].is_a?(Alternative) )
-    assert_equal( true,   subalts[1].is_a?(Alternative) )
+    assert_equal 2, alts.length
+
+    assert_equal true, subalts[0].is_a?(Alternative)
+    assert_equal true, subalts[1].is_a?(Alternative)
   end
 
   def test_parse_alternation_continues_after_nesting
@@ -80,10 +83,10 @@ class ParserAlternation < Test::Unit::TestCase
 
     seq = root.expressions[0][1].expressions
 
-    assert_equal( 2,  seq.length )
+    assert_equal 2, seq.length
 
-    assert_equal( true,   seq[0].is_a?(Group::Capture) )
-    assert_equal( true,   seq[1].is_a?(Literal) )
+    assert_equal true, seq[0].is_a?(Group::Capture)
+    assert_equal true, seq[1].is_a?(Literal)
   end
 
 end

data/test/parser/test_anchors.rb

@@ -18,17 +18,16 @@ class TestParserAnchors < Test::Unit::TestCase
     "\\\\Aa"  => [0, :escape,   :backslash,           EscapeSequence::Literal],
   }
 
-  count = 0
-  tests.each do |pattern, test|
-    define_method "test_parse_anchor_#{test[2]}_#{count+=1}" do
+  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[test[0]]
+      exp  = root.expressions.at(index)
 
-      assert( exp.is_a?( test[3] ),
-             "Expected #{test[3]}, but got #{exp.class.name}")
+      assert exp.is_a?(klass),
+             "Expected #{klass}, but got #{exp.class.name}"
 
-      assert_equal( test[1], exp.type )
-      assert_equal( test[2], exp.token )
+      assert_equal type,  exp.type
+      assert_equal token, exp.token
     end
   end
 

data/test/parser/test_conditionals.rb

@@ -8,12 +8,12 @@ class TestParserConditionals < Test::Unit::TestCase
     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 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.type,   :conditional
+    assert_equal exp.token,  :open
+    assert_equal exp.text,   '(?'
   end
 
 
@@ -23,12 +23,12 @@ class TestParserConditionals < Test::Unit::TestCase
     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 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.type,   :conditional
+    assert_equal exp.token,  :condition
+    assert_equal exp.text,   '(<A>)'
   end
 
 
@@ -37,35 +37,37 @@ class TestParserConditionals < Test::Unit::TestCase
 
     root = RP.parse(regexp, 'ruby/2.0')
 
-    assert_equal( regexp.source, root.to_s )
+    assert_equal regexp.source, root.to_s
 
     group = root.first
-    assert_equal( Group::Capture, group.class )
+    assert_equal Group::Capture, group.class
 
     alt = group.first
-    assert_equal( Alternation, alt.class )
-    assert_equal( 3, alt.length )
+    assert_equal Alternation, alt.class
+    assert_equal 3, alt.length
 
-    assert_equal( true, alt.all? {|exp|
-      exp.first.is_a?(Group::Capture) }
-    )
+    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::Expression, conditional.class
+    assert_equal 3, conditional.length
 
-    assert_equal( Conditional::Condition,  conditional[0].class )
-    assert_equal( '(2)',                   conditional[0].text )
+    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 )
+    assert_equal Conditional::Condition,  condition.class
+    assert_equal '(2)',                   condition.text
 
     branches = conditional.branches
-    assert_equal( 2,      branches.length )
-    assert_equal( Array,  branches.class )
+    assert_equal 2,      branches.length
+    assert_equal Array,  branches.class
   end
 
   def test_parse_conditional_nested
@@ -73,7 +75,7 @@ class TestParserConditionals < Test::Unit::TestCase
 
     root = RP.parse(regexp, 'ruby/2.0')
 
-    assert_equal( regexp.source, root.to_s )
+    assert_equal regexp.source, root.to_s
 
     { 1 => [2, root[1]],
       2 => [2, root[1][1][0]],
@@ -83,9 +85,9 @@ class TestParserConditionals < Test::Unit::TestCase
     }.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 )
+      assert_equal Conditional::Expression, exp.class
+      assert_equal "(#{index})", exp.condition.text
+      assert_equal branch_count, exp.branches.length
     end
   end
 
@@ -95,9 +97,9 @@ class TestParserConditionals < Test::Unit::TestCase
 
     root = RP.parse(regexp, 'ruby/2.0')
 
-    assert_equal( regexp.source, root.to_s )
+    assert_equal regexp.source, root.to_s
 
-    assert_equal( Alternation, root.first.class )
+    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]],
@@ -106,9 +108,9 @@ class TestParserConditionals < Test::Unit::TestCase
     ].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 )
+      assert_equal Alternation, exp.class
+      assert_equal alt_text,    exp.to_s
+      assert_equal alt_count,   exp.alternatives.length
     end
   end
 
@@ -119,20 +121,20 @@ class TestParserConditionals < Test::Unit::TestCase
     root = RP.parse(regexp, 'ruby/2.0')
     branches = root[1].branches
 
-    assert_equal( 2, branches.length )
+    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 seq.is_a?( Sequence ),
+             "Expected Condition, but got #{seq.class.name}"
 
-      assert_equal( :expression, seq.type )
-      assert_equal( :sequence,   seq.token )
+      assert_equal :expression, seq.type
+      assert_equal :sequence,   seq.token
     end
 
-    assert_equal( 'T', seq_1.to_s )
-    assert_equal( '',  seq_2.to_s )
+    assert_equal 'T', seq_1.to_s
+    assert_equal '',  seq_2.to_s
   end
 
 

data/test/parser/test_escapes.rb

@@ -28,48 +28,50 @@ class TestParserEscapes < Test::Unit::TestCase
 
     # unicode escapes
     /a\u{9879}/ => [1, :escape, :codepoint_list,    EscapeSequence::Literal],
+
+     # hex escapes
+    /a\xFF/n =>  [1, :escape, :hex,                 EscapeSequence::Literal],
   }
 
-  count = 0
-  tests.each do |pattern, test|
-    define_method "test_parse_escape_#{test[2]}_#{count+=1}" do
+  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[test[0]]
+      exp  = root.expressions.at(index)
 
-      assert( exp.is_a?( test[3] ),
-             "Expected #{test[3]}, but got #{exp.class.name}")
+      assert exp.is_a?(klass),
+             "Expected #{klass}, but got #{exp.class.name}"
 
-      assert_equal( test[1], exp.type )
-      assert_equal( test[2], exp.token )
+      assert_equal type,  exp.type
+      assert_equal token, exp.token
     end
   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 EscapeSequence::Control, root[2].class
+    assert_equal '\\c2',                  root[2].text
   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 EscapeSequence::Control, root[2].class
+    assert_equal '\\C-C',                 root[2].text
   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 EscapeSequence::Meta, root[2].class
+    assert_equal '\\M-Z',              root[2].text
   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 EscapeSequence::MetaControl, root[2].class
+    assert_equal '\\M-\\C-X',                 root[2].text
   end
 
 end