regexp_parser 0.3.4 → 0.3.5

data/test/parser/test_free_space.rb

@@ -7,13 +7,13 @@ class ParserFreeSpace < Test::Unit::TestCase
     root   = RP.parse(regexp)
 
     0.upto(6) do |i|
-      if i%2 == 1
+      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 )
+        assert_equal WhiteSpace, root[i].class
+        assert_equal '  ',       root[i].text
       else
-        assert_equal( Literal, root[i].class )
-        assert_equal( true,    root[i].quantified? )
+        assert_equal Literal, root[i].class
+        assert_equal true,    root[i].quantified?
       end
     end
   end
@@ -22,8 +22,8 @@ class ParserFreeSpace < Test::Unit::TestCase
     regexp = /a b c d/
     root   = RP.parse(regexp)
 
-    assert_equal( Literal,    root.first.class )
-    assert_equal( 'a b c d',  root.first.text )
+    assert_equal Literal,    root.first.class
+    assert_equal 'a b c d',  root.first.text
   end
 
   def test_parse_free_space_comments
@@ -39,29 +39,29 @@ class ParserFreeSpace < Test::Unit::TestCase
     root = RP.parse(regexp)
 
     alt = root.first
-    assert_equal( Alternation, alt.class )
+    assert_equal Alternation, alt.class
 
     alt_1 = alt.alternatives.first
-    assert_equal( Alternative, alt_1.class )
-    assert_equal( 15, alt_1.length )
+    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 )
+      assert_equal WhiteSpace, alt_1[i].class
     end
 
     [3, 7, 11].each do |i|
-      assert_equal( Comment, alt_1[i].class )
+      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 )
+    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 )
+      assert_equal WhiteSpace, alt_2[i].class
     end
 
-    assert_equal( Comment, alt_2[1].class )
+    assert_equal Comment, alt_2[1].class
   end
 
   def test_parse_free_space_nested_comments
@@ -83,14 +83,14 @@ class ParserFreeSpace < Test::Unit::TestCase
     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 )
+    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 )
+    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|
@@ -98,8 +98,8 @@ class ParserFreeSpace < Test::Unit::TestCase
 
       [3, 7].each do |c|
         comment = group[c]
-        assert_equal( Comment, comment.class )
-        assert_equal( 14,      comment.text.length )
+        assert_equal Comment, comment.class
+        assert_equal 14,      comment.text.length
       end
     end
   end
@@ -121,19 +121,19 @@ class ParserFreeSpace < Test::Unit::TestCase
     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 )
+    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 )
+    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 )
+    assert_equal Literal,        literal_2.class
+    assert_equal true,           literal_2.quantified?
+    assert_equal :one_or_more,   literal_2.quantifier.token
   end
 
 end

data/test/parser/test_groups.rb

@@ -5,104 +5,104 @@ class TestParserGroups < Test::Unit::TestCase
   def test_parse_root_options_mi
     t = RP.parse((/[abc]/mi).to_s, 'ruby/1.8')
 
-    assert_equal( true,  t.m? )
-    assert_equal( true,  t.i? )
-    assert_equal( false, t.x? )
+    assert_equal true,  t.m?
+    assert_equal true,  t.i?
+    assert_equal false, t.x?
   end
 
   def test_parse_nested_options_m
     t = RP.parse('(?xi-m:a(?m-ix:b))', 'ruby/1.8')
 
-    assert_equal( true,  t.expressions[0].expressions[1].m? )
-    assert_equal( false, t.expressions[0].expressions[1].i? )
-    assert_equal( false, t.expressions[0].expressions[1].x? )
+    assert_equal true,  t.expressions[0].expressions[1].m?
+    assert_equal false, t.expressions[0].expressions[1].i?
+    assert_equal false, t.expressions[0].expressions[1].x?
   end
 
   def test_parse_nested_options_xm
     t = RP.parse(/(?i-xm:a(?mx-i:b))/, 'ruby/1.8')
 
-    assert_equal( true,  t.expressions[0].expressions[1].m? )
-    assert_equal( false, t.expressions[0].expressions[1].i? )
-    assert_equal( true,  t.expressions[0].expressions[1].x? )
+    assert_equal true,  t.expressions[0].expressions[1].m?
+    assert_equal false, t.expressions[0].expressions[1].i?
+    assert_equal true,  t.expressions[0].expressions[1].x?
   end
 
   def test_parse_nested_options_im
     t = RP.parse(/(?x-mi:a(?mi-x:b))/, 'ruby/1.8')
 
-    assert_equal( true,  t.expressions[0].expressions[1].m? )
-    assert_equal( true,  t.expressions[0].expressions[1].i? )
-    assert_equal( false, t.expressions[0].expressions[1].x? )
+    assert_equal true,  t.expressions[0].expressions[1].m?
+    assert_equal true,  t.expressions[0].expressions[1].i?
+    assert_equal false, t.expressions[0].expressions[1].x?
   end
 
   if RUBY_VERSION >= '2.0'
     def test_parse_options_dau
       t = RP.parse('(?dua:abc)')
 
-      assert_equal( true,  t.expressions[0].d? )
-      assert_equal( true,  t.expressions[0].a? )
-      assert_equal( true,  t.expressions[0].u? )
+      assert_equal true,  t.expressions[0].d?
+      assert_equal true,  t.expressions[0].a?
+      assert_equal true,  t.expressions[0].u?
     end
 
     def test_parse_nested_options_dau
       t = RP.parse('(?u:a(?d:b))')
 
-      assert_equal( true,  t.expressions[0].u? )
-      assert_equal( false, t.expressions[0].d? )
-      assert_equal( false, t.expressions[0].a? )
+      assert_equal true,  t.expressions[0].u?
+      assert_equal false, t.expressions[0].d?
+      assert_equal false, t.expressions[0].a?
 
-      assert_equal( true,  t.expressions[0].expressions[1].d? )
-      assert_equal( false, t.expressions[0].expressions[1].a? )
-      assert_equal( false, t.expressions[0].expressions[1].u? )
+      assert_equal true,  t.expressions[0].expressions[1].d?
+      assert_equal false, t.expressions[0].expressions[1].a?
+      assert_equal false, t.expressions[0].expressions[1].u?
     end
 
     def test_parse_nested_options_da
       t = RP.parse('(?di-xm:a(?da-x:b))')
 
-      assert_equal( true,  t.expressions[0].d? )
-      assert_equal( true,  t.expressions[0].i? )
-      assert_equal( false, t.expressions[0].m? )
-      assert_equal( false, t.expressions[0].x? )
-      assert_equal( false, t.expressions[0].a? )
-      assert_equal( false, t.expressions[0].u? )
-
-      assert_equal( true,  t.expressions[0].expressions[1].d? )
-      assert_equal( true,  t.expressions[0].expressions[1].a? )
-      assert_equal( false, t.expressions[0].expressions[1].u? )
-      assert_equal( false, t.expressions[0].expressions[1].x? )
-      assert_equal( false, t.expressions[0].expressions[1].m? )
-      assert_equal( false, t.expressions[0].expressions[1].i? )
+      assert_equal true,  t.expressions[0].d?
+      assert_equal true,  t.expressions[0].i?
+      assert_equal false, t.expressions[0].m?
+      assert_equal false, t.expressions[0].x?
+      assert_equal false, t.expressions[0].a?
+      assert_equal false, t.expressions[0].u?
+
+      assert_equal true,  t.expressions[0].expressions[1].d?
+      assert_equal true,  t.expressions[0].expressions[1].a?
+      assert_equal false, t.expressions[0].expressions[1].u?
+      assert_equal false, t.expressions[0].expressions[1].x?
+      assert_equal false, t.expressions[0].expressions[1].m?
+      assert_equal false, t.expressions[0].expressions[1].i?
     end
   end
 
   def test_parse_lookahead
     t = RP.parse('(?=abc)(?!def)', 'ruby/1.8')
 
-    assert( t.expressions[0].is_a?(Assertion::Lookahead),
-           "Expected lookahead, but got #{t.expressions[0].class.name}")
+    assert t.expressions[0].is_a?(Assertion::Lookahead),
+           "Expected lookahead, but got #{t.expressions[0].class.name}"
 
-    assert( t.expressions[1].is_a?(Assertion::NegativeLookahead),
-           "Expected negative lookahead, but got #{t.expressions[0].class.name}")
+    assert t.expressions[1].is_a?(Assertion::NegativeLookahead),
+           "Expected negative lookahead, but got #{t.expressions[0].class.name}"
   end
 
   def test_parse_lookbehind
     t = RP.parse('(?<=abc)(?<!def)', 'ruby/1.9')
 
-    assert( t.expressions[0].is_a?(Assertion::Lookbehind),
-           "Expected lookbehind, but got #{t.expressions[0].class.name}")
+    assert t.expressions[0].is_a?(Assertion::Lookbehind),
+           "Expected lookbehind, but got #{t.expressions[0].class.name}"
 
-    assert( t.expressions[1].is_a?(Assertion::NegativeLookbehind),
-           "Expected negative lookbehind, but got #{t.expressions[0].class.name}")
+    assert t.expressions[1].is_a?(Assertion::NegativeLookbehind),
+           "Expected negative lookbehind, but got #{t.expressions[0].class.name}"
   end
 
   def test_parse_comment
     t = RP.parse('a(?# is for apple)b(?# for boy)c(?# cat)')
 
     [1,3,5].each do |i|
-      assert( t.expressions[i].is_a?(Group::Comment),
-             "Expected comment, but got #{t.expressions[i].class.name}")
+      assert t.expressions[i].is_a?(Group::Comment),
+             "Expected comment, but got #{t.expressions[i].class.name}"
 
-      assert_equal( :group,   t.expressions[i].type )
-      assert_equal( :comment, t.expressions[i].token )
+      assert_equal :group,   t.expressions[i].type
+      assert_equal :comment, t.expressions[i].token
     end
   end
 

data/test/parser/test_keep.rb

@@ -6,16 +6,16 @@ class ParserKeep < Test::Unit::TestCase
     regexp = /ab\Kcd/
     root   = RP.parse(regexp)
 
-    assert_equal( Keep::Mark, root[1].class )
-    assert_equal( '\\K',      root[1].text )
+    assert_equal Keep::Mark, root[1].class
+    assert_equal '\\K',      root[1].text
   end
 
   def test_parse_keep_nested
     regexp = /(a\\\Kb)/
     root   = RP.parse(regexp)
 
-    assert_equal( Keep::Mark, root[0][2].class )
-    assert_equal( '\\K',      root[0][2].text )
+    assert_equal Keep::Mark, root[0][2].class
+    assert_equal '\\K',      root[0][2].text
   end
 
 end

data/test/parser/test_properties.rb

@@ -297,57 +297,59 @@ class ParserProperties < Test::Unit::TestCase
       define_method "test_parse_#{token_type}_#{property}" do
         t = RP.parse "ab\\#{mode}{#{property}}", 'ruby/1.9'
 
-        assert( t.expressions.last.is_a?(UnicodeProperty::Base),
-               "Expected property, but got #{t.expressions.last.class.name}")
+        assert t.expressions.last.is_a?(UnicodeProperty::Base),
+               "Expected property, but got #{t.expressions.last.class.name}"
 
-        assert_equal( token_type, t.expressions.last.type )
-        assert_equal( property,   t.expressions.last.name )
+        assert_equal token_type, t.expressions.last.type
+        assert_equal property,   t.expressions.last.name
       end
     end
   end
 
   def test_parse_property_negative
     t = RP.parse 'ab\p{L}cd', 'ruby/1.9'
-    assert_equal( false, t.expressions[1].negative? )
+
+    assert_equal false, t.expressions[1].negative?
   end
 
   def test_parse_nonproperty_negative
     t = RP.parse 'ab\P{L}cd', 'ruby/1.9'
-    assert_equal( true, t.expressions[1].negative? )
+
+    assert_equal true, t.expressions[1].negative?
   end
 
   def test_parse_property_age
     t = RP.parse 'ab\p{age=5.2}cd', 'ruby/1.9'
 
-    assert( t.expressions[1].is_a?(UnicodeProperty::Age),
-           "Expected Age property, but got #{t.expressions[1].class.name}")
+    assert t.expressions[1].is_a?(UnicodeProperty::Age),
+           "Expected Age property, but got #{t.expressions[1].class.name}"
   end
 
   def test_parse_property_derived
     t = RP.parse 'ab\p{Math}cd', 'ruby/1.9'
 
-    assert( t.expressions[1].is_a?(UnicodeProperty::Derived),
-           "Expected Derived property, but got #{t.expressions[1].class.name}")
+    assert t.expressions[1].is_a?(UnicodeProperty::Derived),
+           "Expected Derived property, but got #{t.expressions[1].class.name}"
   end
 
   def test_parse_property_script
     t = RP.parse 'ab\p{Hiragana}cd', 'ruby/1.9'
 
-    assert( t.expressions[1].is_a?(UnicodeProperty::Script),
-           "Expected Script property, but got #{t.expressions[1].class.name}")
+    assert t.expressions[1].is_a?(UnicodeProperty::Script),
+           "Expected Script property, but got #{t.expressions[1].class.name}"
   end
 
   def test_parse_property_block
     t = RP.parse 'ab\p{InArmenian}cd', 'ruby/1.9'
 
-    assert( t.expressions[1].is_a?(UnicodeProperty::Block),
-           "Expected Block property, but got #{t.expressions[1].class.name}")
+    assert t.expressions[1].is_a?(UnicodeProperty::Block),
+           "Expected Block property, but got #{t.expressions[1].class.name}"
   end
 
   def test_parse_property_following_literal
     t = RP.parse 'ab\p{Lu}cd', 'ruby/1.9'
 
-    assert( t.expressions[2].is_a?(Literal),
-           "Expected Literal, but got #{t.expressions[2].class.name}")
+    assert t.expressions[2].is_a?(Literal),
+           "Expected Literal, but got #{t.expressions[2].class.name}"
   end
 end

data/test/parser/test_quantifiers.rb

@@ -4,235 +4,256 @@ class TestRegexpParserQuantifiers < Test::Unit::TestCase
 
   # ?: zero-or-one
   def test_parse_zero_or_one_greedy
-    t = RP.parse('a?bc')
-
-    assert_equal( true, t.expressions.first.quantified? )
-    assert_equal( :zero_or_one, t.expressions.first.quantifier.token )
-    assert_equal( 0, t.expressions.first.quantifier.min )
-    assert_equal( 1, t.expressions.first.quantifier.max )
-    assert_equal( :greedy, t.expressions.first.quantifier.mode )
+    root = RP.parse('a?bc')
+    exp  = root.expressions.first
+
+    assert_equal true,          exp.quantified?
+    assert_equal :zero_or_one,  exp.quantifier.token
+    assert_equal 0,             exp.quantifier.min
+    assert_equal 1,             exp.quantifier.max
+    assert_equal :greedy,       exp.quantifier.mode
   end
 
   def test_parse_zero_or_one_reluctant
-    t = RP.parse('a??bc')
-
-    assert_equal( true, t.expressions.first.quantified? )
-    assert_equal( :zero_or_one, t.expressions.first.quantifier.token )
-    assert_equal( 0, t.expressions.first.quantifier.min )
-    assert_equal( 1, t.expressions.first.quantifier.max )
-    assert_equal( :reluctant, t.expressions.first.quantifier.mode )
-    assert_equal( true, t.expressions.first.reluctant? )
+    root = RP.parse('a??bc')
+    exp  = root.expressions.first
+
+    assert_equal true,          exp.quantified?
+    assert_equal :zero_or_one,  exp.quantifier.token
+    assert_equal 0,             exp.quantifier.min
+    assert_equal 1,             exp.quantifier.max
+    assert_equal :reluctant,    exp.quantifier.mode
+    assert_equal true,          exp.reluctant?
   end
 
   def test_parse_zero_or_one_possessive
-    t = RP.parse('a?+bc', 'ruby/1.9')
-
-    assert_equal( true, t.expressions.first.quantified? )
-    assert_equal( :zero_or_one, t.expressions.first.quantifier.token )
-    assert_equal( 0, t.expressions.first.quantifier.min )
-    assert_equal( 1, t.expressions.first.quantifier.max )
-    assert_equal( :possessive, t.expressions.first.quantifier.mode )
-    assert_equal( true, t.expressions.first.possessive? )
+    root = RP.parse('a?+bc', 'ruby/1.9')
+    exp  = root.expressions.first
+
+    assert_equal true,          exp.quantified?
+    assert_equal :zero_or_one,  exp.quantifier.token
+    assert_equal 0,             exp.quantifier.min
+    assert_equal 1,             exp.quantifier.max
+    assert_equal :possessive,   exp.quantifier.mode
+    assert_equal true,          exp.possessive?
   end
 
   # *: zero-or-more
   def test_parse_zero_or_more_greedy
-    t = RP.parse('a*bc')
-
-    assert_equal( true, t.expressions.first.quantified? )
-    assert_equal( :zero_or_more, t.expressions.first.quantifier.token )
-    assert_equal( 0, t.expressions.first.quantifier.min )
-    assert_equal( -1, t.expressions.first.quantifier.max )
-    assert_equal( :greedy, t.expressions.first.quantifier.mode )
+    root = RP.parse('a*bc')
+    exp  = root.expressions.first
+
+    assert_equal true,          exp.quantified?
+    assert_equal :zero_or_more, exp.quantifier.token
+    assert_equal 0,             exp.quantifier.min
+    assert_equal -1,            exp.quantifier.max
+    assert_equal :greedy,       exp.quantifier.mode
   end
 
   def test_parse_zero_or_more_reluctant
-    t = RP.parse('a*?bc')
-
-    assert_equal( true, t.expressions.first.quantified? )
-    assert_equal( :zero_or_more, t.expressions.first.quantifier.token )
-    assert_equal( 0, t.expressions.first.quantifier.min )
-    assert_equal( -1, t.expressions.first.quantifier.max )
-    assert_equal( :reluctant, t.expressions.first.quantifier.mode )
-    assert_equal( true, t.expressions.first.reluctant? )
+    root = RP.parse('a*?bc')
+    exp  = root.expressions.first
+
+    assert_equal true,          exp.quantified?
+    assert_equal :zero_or_more, exp.quantifier.token
+    assert_equal 0,             exp.quantifier.min
+    assert_equal -1,            exp.quantifier.max
+    assert_equal :reluctant,    exp.quantifier.mode
+    assert_equal true,          exp.reluctant?
   end
 
   def test_parse_zero_or_more_possessive
-    t = RP.parse('a*+bc', 'ruby/1.9')
-
-    assert_equal( true, t.expressions.first.quantified? )
-    assert_equal( :zero_or_more, t.expressions.first.quantifier.token )
-    assert_equal( 0, t.expressions.first.quantifier.min )
-    assert_equal( -1, t.expressions.first.quantifier.max )
-    assert_equal( :possessive, t.expressions.first.quantifier.mode )
-    assert_equal( true, t.expressions.first.possessive? )
+    root = RP.parse('a*+bc', 'ruby/1.9')
+    exp  = root.expressions.first
+
+    assert_equal true,          exp.quantified?
+    assert_equal :zero_or_more, exp.quantifier.token
+    assert_equal 0,             exp.quantifier.min
+    assert_equal -1,            exp.quantifier.max
+    assert_equal :possessive,   exp.quantifier.mode
+    assert_equal true,          exp.possessive?
   end
 
   # +: one-or-more
   def test_parse_one_or_more_greedy
-    t = RP.parse('a+bc')
-
-    assert_equal( true, t.expressions.first.quantified? )
-    assert_equal( :one_or_more, t.expressions.first.quantifier.token )
-    assert_equal( 1, t.expressions.first.quantifier.min )
-    assert_equal( -1, t.expressions.first.quantifier.max )
-    assert_equal( :greedy, t.expressions.first.quantifier.mode )
+    root = RP.parse('a+bc')
+    exp  = root.expressions.first
+
+    assert_equal true,          exp.quantified?
+    assert_equal :one_or_more,  exp.quantifier.token
+    assert_equal 1,             exp.quantifier.min
+    assert_equal -1,            exp.quantifier.max
+    assert_equal :greedy,       exp.quantifier.mode
   end
 
   def test_parse_one_or_more_reluctant
-    t = RP.parse('a+?bc')
-
-    assert_equal( true, t.expressions.first.quantified? )
-    assert_equal( :one_or_more, t.expressions.first.quantifier.token )
-    assert_equal( 1, t.expressions.first.quantifier.min )
-    assert_equal( -1, t.expressions.first.quantifier.max )
-    assert_equal( :reluctant, t.expressions.first.quantifier.mode )
-    assert_equal( true, t.expressions.first.reluctant? )
+    root = RP.parse('a+?bc')
+    exp  = root.expressions.first
+
+    assert_equal true,          exp.quantified?
+    assert_equal :one_or_more,  exp.quantifier.token
+    assert_equal 1,             exp.quantifier.min
+    assert_equal -1,            exp.quantifier.max
+    assert_equal :reluctant,    exp.quantifier.mode
+    assert_equal true,          exp.reluctant?
   end
 
   def test_parse_one_or_more_possessive
-    t = RP.parse('a++bc', 'ruby/1.9')
-
-    assert_equal( true, t.expressions.first.quantified? )
-    assert_equal( :one_or_more, t.expressions.first.quantifier.token )
-    assert_equal( 1, t.expressions.first.quantifier.min )
-    assert_equal( -1, t.expressions.first.quantifier.max )
-    assert_equal( :possessive, t.expressions.first.quantifier.mode )
-    assert_equal( true, t.expressions.first.possessive? )
+    root = RP.parse('a++bc', 'ruby/1.9')
+    exp  = root.expressions.first
+
+    assert_equal true,          exp.quantified?
+    assert_equal :one_or_more,  exp.quantifier.token
+    assert_equal 1,             exp.quantifier.min
+    assert_equal -1,            exp.quantifier.max
+    assert_equal :possessive,   exp.quantifier.mode
+    assert_equal true,          exp.possessive?
   end
 
   # interval: min and max
   def test_parse_intervals_min_max_greedy
-    t = RP.parse('a{2,4}bc')
-
-    assert_equal( true, t.expressions.first.quantified? )
-    assert_equal( :interval, t.expressions.first.quantifier.token )
-    assert_equal( 2, t.expressions.first.quantifier.min)
-    assert_equal( 4, t.expressions.first.quantifier.max)
-    assert_equal( :greedy, t.expressions.first.quantifier.mode )
+    root = RP.parse('a{2,4}bc')
+    exp  = root.expressions.first
+
+    assert_equal true,      exp.quantified?
+    assert_equal :interval, exp.quantifier.token
+    assert_equal 2,         exp.quantifier.min
+    assert_equal 4,         exp.quantifier.max
+    assert_equal :greedy,   exp.quantifier.mode
   end
 
   def test_parse_intervals_min_max_reluctant
-    t = RP.parse('a{3,5}?bc')
-
-    assert_equal( true, t.expressions.first.quantified? )
-    assert_equal( :interval, t.expressions.first.quantifier.token )
-    assert_equal( 3, t.expressions.first.quantifier.min)
-    assert_equal( 5, t.expressions.first.quantifier.max)
-    assert_equal( :reluctant, t.expressions.first.quantifier.mode )
-    assert_equal( true, t.expressions.first.reluctant? )
+    root = RP.parse('a{3,5}?bc')
+    exp  = root.expressions.first
+
+    assert_equal true,        exp.quantified?
+    assert_equal :interval,   exp.quantifier.token
+    assert_equal 3,           exp.quantifier.min
+    assert_equal 5,           exp.quantifier.max
+    assert_equal :reluctant,  exp.quantifier.mode
+    assert_equal true,        exp.reluctant?
   end
 
   def test_parse_intervals_min_max_possessive
-    t = RP.parse('a{2,4}+bc', 'ruby/1.9')
-
-    assert_equal( true, t.expressions.first.quantified? )
-    assert_equal( :interval, t.expressions.first.quantifier.token )
-    assert_equal( 2, t.expressions.first.quantifier.min)
-    assert_equal( 4, t.expressions.first.quantifier.max)
-    assert_equal( :possessive, t.expressions.first.quantifier.mode )
-    assert_equal( true, t.expressions.first.possessive? )
+    root = RP.parse('a{2,4}+bc', 'ruby/1.9')
+    exp  = root.expressions.first
+
+    assert_equal true,        exp.quantified?
+    assert_equal :interval,   exp.quantifier.token
+    assert_equal 2,           exp.quantifier.min
+    assert_equal 4,           exp.quantifier.max
+    assert_equal :possessive, exp.quantifier.mode
+    assert_equal true,        exp.possessive?
   end
 
   # interval: min only
   def test_parse_intervals_min_only_greedy
-    t = RP.parse('a{2,}bc')
-
-    assert_equal( true, t.expressions.first.quantified? )
-    assert_equal( :interval, t.expressions.first.quantifier.token )
-    assert_equal( 2, t.expressions.first.quantifier.min)
-    assert_equal( -1, t.expressions.first.quantifier.max)
-    assert_equal( :greedy, t.expressions.first.quantifier.mode )
+    root = RP.parse('a{2,}bc')
+    exp  = root.expressions.first
+
+    assert_equal true,      exp.quantified?
+    assert_equal :interval, exp.quantifier.token
+    assert_equal 2,         exp.quantifier.min
+    assert_equal -1,        exp.quantifier.max
+    assert_equal :greedy,   exp.quantifier.mode
   end
 
   def test_parse_intervals_min_only_reluctant
-    t = RP.parse('a{2,}?bc')
-
-    assert_equal( true, t.expressions.first.quantified? )
-    assert_equal( :interval, t.expressions.first.quantifier.token )
-    assert_equal( '{2,}?', t.expressions.first.quantifier.text )
-    assert_equal( 2, t.expressions.first.quantifier.min)
-    assert_equal( -1, t.expressions.first.quantifier.max)
-    assert_equal( :reluctant, t.expressions.first.quantifier.mode )
-    assert_equal( true, t.expressions.first.reluctant? )
+    root = RP.parse('a{2,}?bc')
+    exp  = root.expressions.first
+
+    assert_equal true,        exp.quantified?
+    assert_equal :interval,   exp.quantifier.token
+    assert_equal '{2,}?',     exp.quantifier.text
+    assert_equal 2,           exp.quantifier.min
+    assert_equal -1,          exp.quantifier.max
+    assert_equal :reluctant,  exp.quantifier.mode
+    assert_equal true,        exp.reluctant?
   end
 
   def test_parse_intervals_min_only_possessive
-    t = RP.parse('a{3,}+bc', 'ruby/1.9')
-
-    assert_equal( true, t.expressions.first.quantified? )
-    assert_equal( :interval, t.expressions.first.quantifier.token )
-    assert_equal( '{3,}+', t.expressions.first.quantifier.text )
-    assert_equal( 3, t.expressions.first.quantifier.min)
-    assert_equal( -1, t.expressions.first.quantifier.max)
-    assert_equal( :possessive, t.expressions.first.quantifier.mode )
-    assert_equal( true, t.expressions.first.possessive? )
+    root = RP.parse('a{3,}+bc', 'ruby/1.9')
+    exp  = root.expressions.first
+
+    assert_equal true,        exp.quantified?
+    assert_equal :interval,   exp.quantifier.token
+    assert_equal '{3,}+',     exp.quantifier.text
+    assert_equal 3,           exp.quantifier.min
+    assert_equal -1,          exp.quantifier.max
+    assert_equal :possessive, exp.quantifier.mode
+    assert_equal true,        exp.possessive?
   end
 
   # interval: max only
   def test_parse_intervals_max_only_greedy
-    t = RP.parse('a{,2}bc')
-
-    assert_equal( true, t.expressions.first.quantified? )
-    assert_equal( :interval, t.expressions.first.quantifier.token )
-    assert_equal( 0, t.expressions.first.quantifier.min)
-    assert_equal( 2, t.expressions.first.quantifier.max)
-    assert_equal( :greedy, t.expressions.first.quantifier.mode )
+    root = RP.parse('a{,2}bc')
+    exp  = root.expressions.first
+
+    assert_equal true,      exp.quantified?
+    assert_equal :interval, exp.quantifier.token
+    assert_equal 0,         exp.quantifier.min
+    assert_equal 2,         exp.quantifier.max
+    assert_equal :greedy,   exp.quantifier.mode
   end
 
   def test_parse_intervals_max_only_reluctant
-    t = RP.parse('a{,4}?bc')
-
-    assert_equal( true, t.expressions.first.quantified? )
-    assert_equal( :interval, t.expressions.first.quantifier.token )
-    assert_equal( 0, t.expressions.first.quantifier.min)
-    assert_equal( 4, t.expressions.first.quantifier.max)
-    assert_equal( :reluctant, t.expressions.first.quantifier.mode )
-    assert_equal( true, t.expressions.first.reluctant? )
+    root = RP.parse('a{,4}?bc')
+    exp  = root.expressions.first
+
+    assert_equal true,        exp.quantified?
+    assert_equal :interval,   exp.quantifier.token
+    assert_equal 0,           exp.quantifier.min
+    assert_equal 4,           exp.quantifier.max
+    assert_equal :reluctant,  exp.quantifier.mode
+    assert_equal true,        exp.reluctant?
   end
 
   def test_parse_intervals_max_only_possessive
-    t = RP.parse('a{,3}+bc', 'ruby/1.9')
-
-    assert_equal( true, t.expressions.first.quantified? )
-    assert_equal( :interval, t.expressions.first.quantifier.token )
-    assert_equal( 0, t.expressions.first.quantifier.min)
-    assert_equal( 3, t.expressions.first.quantifier.max)
-    assert_equal( :possessive, t.expressions.first.quantifier.mode )
-    assert_equal( true, t.expressions.first.possessive? )
+    root = RP.parse('a{,3}+bc', 'ruby/1.9')
+    exp  = root.expressions.first
+
+    assert_equal true,        exp.quantified?
+    assert_equal :interval,   exp.quantifier.token
+    assert_equal 0,           exp.quantifier.min
+    assert_equal 3,           exp.quantifier.max
+    assert_equal :possessive, exp.quantifier.mode
+    assert_equal true,        exp.possessive?
   end
 
   # interval: exact
   def test_parse_intervals_exact_greedy
-    t = RP.parse('a{2}bc')
-
-    assert_equal( true, t.expressions.first.quantified? )
-    assert_equal( :interval, t.expressions.first.quantifier.token )
-    assert_equal( 2, t.expressions.first.quantifier.min)
-    assert_equal( 2, t.expressions.first.quantifier.max)
-    assert_equal( :greedy, t.expressions.first.quantifier.mode )
+    root = RP.parse('a{2}bc')
+    exp  = root.expressions.first
+
+    assert_equal true,      exp.quantified?
+    assert_equal :interval, exp.quantifier.token
+    assert_equal 2,         exp.quantifier.min
+    assert_equal 2,         exp.quantifier.max
+    assert_equal :greedy,   exp.quantifier.mode
   end
 
   def test_parse_intervals_exact_reluctant
-    t = RP.parse('a{3}?bc')
-
-    assert_equal( true, t.expressions.first.quantified? )
-    assert_equal( :interval, t.expressions.first.quantifier.token )
-    assert_equal( 3, t.expressions.first.quantifier.min)
-    assert_equal( 3, t.expressions.first.quantifier.max)
-    assert_equal( :reluctant, t.expressions.first.quantifier.mode )
-    assert_equal( true, t.expressions.first.reluctant? )
+    root = RP.parse('a{3}?bc')
+    exp  = root.expressions.first
+
+    assert_equal true,        exp.quantified?
+    assert_equal :interval,   exp.quantifier.token
+    assert_equal 3,           exp.quantifier.min
+    assert_equal 3,           exp.quantifier.max
+    assert_equal :reluctant,  exp.quantifier.mode
+    assert_equal true,        exp.reluctant?
   end
 
   def test_parse_intervals_exact_possessive
-    t = RP.parse('a{3}+bc', 'ruby/1.9')
-
-    assert_equal( true, t.expressions.first.quantified? )
-    assert_equal( :interval, t.expressions.first.quantifier.token )
-    assert_equal( 3, t.expressions.first.quantifier.min)
-    assert_equal( 3, t.expressions.first.quantifier.max)
-    assert_equal( :possessive, t.expressions.first.quantifier.mode )
-    assert_equal( true, t.expressions.first.possessive? )
+    root = RP.parse('a{3}+bc', 'ruby/1.9')
+    exp  = root.expressions.first
+
+    assert_equal true,        exp.quantified?
+    assert_equal :interval,   exp.quantifier.token
+    assert_equal 3,           exp.quantifier.min
+    assert_equal 3,           exp.quantifier.max
+    assert_equal :possessive, exp.quantifier.mode
+    assert_equal true,        exp.possessive?
   end
 
 end