regexp_parser 0.3.4 → 0.3.5

data/test/expression/test_to_h.rb

@@ -3,9 +3,11 @@ require File.expand_path("../../helpers", __FILE__)
 class ExpressionToH < Test::Unit::TestCase
 
   def test_expression_to_h
-    h = RP.parse('abc').to_h
+    root = RP.parse('abc')
 
-    assert_equal( h, {
+    hash = root.to_h
+
+    assert_equal hash, {
       :token             => :root,
       :type              => :expression,
       :text              => 'abc',
@@ -30,19 +32,22 @@ class ExpressionToH < Test::Unit::TestCase
           :conditional_level => 0
         }
       ]
-    })
+    }
   end
 
   def test_expression_quantifier_to_h
-    h = RP.parse('a{2,4}')[0].quantifier.to_h
+    root = RP.parse('a{2,4}')
+    exp  = root.expressions.at(0)
+
+    hash = exp.quantifier.to_h
 
-    assert_equal( h, {
+    assert_equal hash, {
       :max   => 4,
       :min   => 2,
       :mode  => :greedy,
       :text  => '{2,4}',
       :token => :interval
-    })
+    }
   end
 
 end

data/test/expression/test_to_s.rb

@@ -4,48 +4,57 @@ class ExpressionToS < Test::Unit::TestCase
 
   def test_expression_to_s_literal_alternation
     pattern = 'abcd|ghij|klmn|pqur'
-    assert_equal( pattern, RP.parse(pattern).to_s )
+
+    assert_equal pattern, RP.parse(pattern).to_s
   end
 
   def test_expression_to_s_quantified_alternations
     pattern = '(?:a?[b]+(c){2}|d+[e]*(f)?)|(?:g+[h]?(i){2,3}|j*[k]{3,5}(l)?)'
-    assert_equal( pattern, RP.parse(pattern).to_s )
+
+    assert_equal pattern, RP.parse(pattern).to_s
   end
 
   def test_expression_to_s_quantified_sets
     pattern = '[abc]+|[^def]{3,6}'
-    assert_equal( pattern, RP.parse(pattern).to_s )
+
+    assert_equal pattern, RP.parse(pattern).to_s
   end
 
   def test_expression_to_s_property_sets
     pattern = '[\a\b\p{Lu}\P{Z}\c\d]+'
-    assert_equal( pattern, RP.parse(pattern, 'ruby/1.9').to_s )
+
+    assert_equal pattern, RP.parse(pattern, 'ruby/1.9').to_s
   end
 
   def test_expression_to_s_groups
     pattern = "(a(?>b(?:c(?<n>d(?'N'e)??f)+g)*+h)*i)++"
-    assert_equal( pattern, RP.parse(pattern, 'ruby/1.9').to_s )
+
+    assert_equal pattern, RP.parse(pattern, 'ruby/1.9').to_s
   end
 
   def test_expression_to_s_assertions
     pattern = '(a+(?=b+(?!c+(?<=d+(?<!e+)?f+)?g+)?h+)?i+)?'
-    assert_equal( pattern, RP.parse(pattern, 'ruby/1.9').to_s )
+
+    assert_equal pattern, RP.parse(pattern, 'ruby/1.9').to_s
   end
 
   def test_expression_to_s_comments
     pattern = '(?#start)a(?#middle)b(?#end)'
-    assert_equal( pattern, RP.parse(pattern).to_s )
+
+    assert_equal pattern, RP.parse(pattern).to_s
   end
 
   def test_expression_to_s_options
     pattern = '(?mix:start)a(?-mix:middle)b(?i-mx:end)'
-    assert_equal( pattern, RP.parse(pattern).to_s )
+
+    assert_equal pattern, RP.parse(pattern).to_s
   end
 
   def test_expression_to_s_url
     pattern = '(^$)|(^(http|https):\/\/[a-z0-9]+([\-\.]{1}[a-z0-9]+)*'+
               '\.[a-z]{2,5}(([0-9]{1,5})?\/.*)?$)'
-    assert_equal( pattern, RP.parse(pattern).to_s )
+
+    assert_equal pattern, RP.parse(pattern).to_s
   end
 
   def test_expression_to_s_multiline_source
@@ -57,7 +66,7 @@ class ExpressionToS < Test::Unit::TestCase
       \z
     }x
 
-    assert_equal( multiline.source, RP.parse(multiline).to_s )
+    assert_equal multiline.source, RP.parse(multiline).to_s
   end
 
   def test_expression_to_s_multiline_to_s
@@ -69,7 +78,7 @@ class ExpressionToS < Test::Unit::TestCase
       \z
     }x
 
-    assert_equal( multiline.to_s, RP.parse(multiline.to_s).to_s )
+    assert_equal multiline.to_s, RP.parse(multiline.to_s).to_s
   end
 
   # Free spacing expressions that use spaces between quantifiers and their
@@ -88,10 +97,8 @@ class ExpressionToS < Test::Unit::TestCase
     str  = 'bbbcged'
     root = RP.parse(multiline)
 
-    assert_equal(
-      multiline.match(str)[0],
-      Regexp.new(root.to_s, Regexp::EXTENDED).match(str)[0]
-    )
+    assert_equal multiline.match(str)[0],
+                 Regexp.new(root.to_s, Regexp::EXTENDED).match(str)[0]
   end
 
 end

data/test/expression/test_traverse.rb

@@ -15,10 +15,10 @@ class SubexpressionTraverse < Test::Unit::TestCase
       exits  += 1 if event == :exit
     }
 
-    assert_equal( 7, enters )
-    assert_equal( exits, enters )
+    assert_equal 7,     enters
+    assert_equal exits, enters
 
-    assert_equal( 8, visits )
+    assert_equal 8, visits
   end
 
   def test_subexpression_traverse_include_self
@@ -34,16 +34,16 @@ class SubexpressionTraverse < Test::Unit::TestCase
       exits  += 1 if event == :exit
     }
 
-    assert_equal( 8, enters )
-    assert_equal( exits, enters )
+    assert_equal 8,     enters
+    assert_equal exits, enters
 
-    assert_equal( 8, visits )
+    assert_equal 8, visits
   end
 
   def test_subexpression_walk_alias
     root = RP.parse(/abc/)
 
-    assert_equal( true, root.respond_to?(:walk) )
+    assert_equal true, root.respond_to?(:walk)
   end
 
   def test_subexpression_each_expression
@@ -54,7 +54,7 @@ class SubexpressionTraverse < Test::Unit::TestCase
       count += 1
     }
 
-    assert_equal( 10, count )
+    assert_equal 10, count
   end
 
   def test_subexpression_each_expression_include_self
@@ -65,7 +65,7 @@ class SubexpressionTraverse < Test::Unit::TestCase
       count += 1
     }
 
-    assert_equal( 11, count )
+    assert_equal 11, count
   end
 
   def test_subexpression_each_expression_indices
@@ -74,7 +74,7 @@ class SubexpressionTraverse < Test::Unit::TestCase
     indices = []
     root.each_expression {|exp, index| indices << index}
 
-    assert_equal( [0, 1, 0, 2], indices )
+    assert_equal [0, 1, 0, 2], indices
   end
 
   def test_subexpression_each_expression_indices_include_self
@@ -83,7 +83,7 @@ class SubexpressionTraverse < Test::Unit::TestCase
     indices = []
     root.each_expression(true) {|exp, index| indices << index}
 
-    assert_equal( [0, 0, 1, 0, 2], indices )
+    assert_equal [0, 0, 1, 0, 2], indices
   end
 
   def test_subexpression_map_without_block
@@ -91,14 +91,14 @@ class SubexpressionTraverse < Test::Unit::TestCase
 
     array = root.map
 
-    assert_equal( Array, array.class )
-    assert_equal( 5, array.length )
+    assert_equal Array, array.class
+    assert_equal 5, array.length
 
     array.each do |item|
-      assert_equal( Array, item.class )
-      assert_equal( 2, item.length )
-      assert_equal( true, item.first.is_a?(Regexp::Expression::Base) )
-      assert_equal( true, item.last.is_a?(Fixnum) )
+      assert_equal Array, item.class
+      assert_equal 2,     item.length
+      assert_equal true,  item.first.is_a?(Regexp::Expression::Base)
+      assert_equal true,  item.last.is_a?(Fixnum)
     end
   end
 
@@ -107,8 +107,8 @@ class SubexpressionTraverse < Test::Unit::TestCase
 
     array = root.map(true)
 
-    assert_equal( Array, array.class )
-    assert_equal( 6, array.length )
+    assert_equal Array, array.class
+    assert_equal 6, array.length
   end
 
   def test_subexpression_map_indices
@@ -116,7 +116,7 @@ class SubexpressionTraverse < Test::Unit::TestCase
 
     indices = root.map {|exp, index| index}
 
-    assert_equal( [0, 1, 0, 1, 0, 2, 3], indices )
+    assert_equal [0, 1, 0, 1, 0, 2, 3], indices
   end
 
   def test_subexpression_map_indices_include_self
@@ -124,7 +124,7 @@ class SubexpressionTraverse < Test::Unit::TestCase
 
     indices = root.map(true) {|exp, index| index}
 
-    assert_equal( [0, 0, 1, 0, 1, 0, 2, 3], indices )
+    assert_equal [0, 0, 1, 0, 1, 0, 2, 3], indices
   end
 
   def test_subexpression_map_expressions
@@ -134,10 +134,9 @@ class SubexpressionTraverse < Test::Unit::TestCase
       [exp.level, exp.text] if exp.terminal?
     }.compact
 
-    assert_equal(
-      [[0, 'a'], [1, 'b'], [2, 'c'], [3, 'd']],
-      levels
-    )
+    assert_equal [
+        [0, 'a'], [1, 'b'], [2, 'c'], [3, 'd']
+      ], levels
   end
 
   def test_subexpression_map_expressions_include_self
@@ -147,7 +146,7 @@ class SubexpressionTraverse < Test::Unit::TestCase
       [exp.level, exp.to_s]
     }.compact
 
-    assert_equal( [
+    assert_equal [
         [nil, 'a(b(c(d)))'],
         [0,   'a'],
         [0,   '(b(c(d)))'],
@@ -156,9 +155,7 @@ class SubexpressionTraverse < Test::Unit::TestCase
         [2,   'c'],
         [2,   '(d)'],
         [3,   'd']
-      ],
-      levels
-    )
+      ], levels
   end
 
 end

data/test/lexer/test_all.rb

@@ -15,25 +15,27 @@ end
 class TestRegexpLexer < Test::Unit::TestCase
 
   def test_lexer_returns_an_array
-    assert_instance_of( Array, RL.lex('abc'))
+    assert_instance_of Array, RL.lex('abc')
   end
 
   def test_lexer_returns_tokens
     tokens = RL.lex('^abc+[^one]{2,3}\b\d\\\C-C$')
-    assert( tokens.all?{|token| token.kind_of?(Regexp::Token)},
-          "Not all array members are tokens")
 
-    assert( tokens.all?{|token| token.to_a.length == 8},
-          "Not all tokens have a length of 8")
+    assert tokens.all?{ |token| token.kind_of?(Regexp::Token) },
+          "Not all array members are tokens"
+
+    assert tokens.all?{ |token| token.to_a.length == 8 },
+          "Not all tokens have a length of 8"
   end
 
   def test_lexer_token_count
     tokens = RL.lex(/^(one|two){2,3}([^d\]efm-qz\,\-]*)(ghi)+$/i)
-    assert_equal( 26, tokens.length )
+
+    assert_equal 26, tokens.length
   end
 
   def test_lexer_scan_alias
-    assert_equal( RL.lex(/a|b|c/), RL.scan(/a|b|c/) )
+    assert_equal RL.lex(/a|b|c/), RL.scan(/a|b|c/)
   end
 
 end

data/test/lexer/test_conditionals.rb

@@ -1,7 +1,6 @@
 require File.expand_path("../../helpers", __FILE__)
 
 class LexerConditionals < Test::Unit::TestCase
-
   if RUBY_VERSION >= '2.0'
 
   # Basic lexer output and nesting tests
@@ -12,11 +11,19 @@ class LexerConditionals < Test::Unit::TestCase
     '(?<D>a)(?(<D>)b|c)'  => [8, :conditional, :close,      ')',     17, 18, 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)
-      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
 
@@ -45,8 +52,17 @@ class LexerConditionals < Test::Unit::TestCase
 
       [22, :group,       :close,            ')',      44, 45, 1, 0, 0],
       [23, :group,       :close,            ')',      45, 46, 0, 0, 0]
-    ].each do |test|
-      assert_equal( test[1,8], tokens[test[0]].to_a)
+    ].each do |index, type, token, text, ts, te, level, set_level, conditional_level|
+      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
 
@@ -91,11 +107,19 @@ class LexerConditionals < Test::Unit::TestCase
       [35, :conditional, :close,      ')',    53, 54, 0, 0, 2],
       [36, :conditional, :close,      ')',    54, 55, 0, 0, 1],
       [37, :conditional, :close,      ')',    55, 56, 0, 0, 0]
-    ].each do |test|
-      assert_equal( test[1,8], tokens[test[0]].to_a)
+    ].each do |index, type, token, text, ts, te, level, set_level, conditional_level|
+      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
 
-  end
-
+  end # if RUBY_VERSION >= '2.0'
 end

data/test/lexer/test_keep.rb

@@ -6,19 +6,19 @@ class LexerKeep < Test::Unit::TestCase
     regexp = /ab\Kcd/
     tokens = RL.lex(regexp)
 
-    assert_equal( :keep, tokens[1].type )
-    assert_equal( :mark, tokens[1].token )
+    assert_equal :keep, tokens[1].type
+    assert_equal :mark, tokens[1].token
   end
 
   def test_lex_keep_nested
     regexp = /(a\Kb)|(c\\\Kd)ef/
     tokens = RL.lex(regexp)
 
-    assert_equal( :keep, tokens[2].type )
-    assert_equal( :mark, tokens[2].token )
+    assert_equal :keep, tokens[2].type
+    assert_equal :mark, tokens[2].token
 
-    assert_equal( :keep, tokens[9].type )
-    assert_equal( :mark, tokens[9].token )
+    assert_equal :keep, tokens[9].type
+    assert_equal :mark, tokens[9].token
   end
 
 end

data/test/lexer/test_literals.rb

@@ -90,31 +90,41 @@ class LexerLiterals < Test::Unit::TestCase
     },
   }
 
-  count = 0
-  tests.each do |pattern, checks|
-    define_method "test_lex_literal_runs_#{count+=1}" do
-
+  tests.each_with_index do |(pattern, checks), count|
+    define_method "test_lex_literal_runs_#{count}" do
       tokens = RL.lex(pattern)
-      checks.each do |offset, token|
-        assert_equal( token, tokens[offset].to_a )
-      end
 
+      checks.each do |index, (type, token, text, ts, te, level, set_level, conditional_level)|
+        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
   end
 
   def test_lex_single_2_byte_char
     tokens = RL.lex('ا+')
-    assert_equal( 2, tokens.length )
+
+    assert_equal 2, tokens.length
   end
 
   def test_lex_single_3_byte_char
     tokens = RL.lex('れ+')
-    assert_equal( 2, tokens.length )
+
+    assert_equal 2, tokens.length
   end
 
   def test_lex_single_4_byte_char
     tokens = RL.lex('𝄞+')
-    assert_equal( 2, tokens.length )
+
+    assert_equal 2, tokens.length
   end
 
 end