regexp_parser 0.5.0 → 1.0.0

data/lib/regexp_parser/syntax/versions/1.8.6.rb

@@ -6,7 +6,7 @@ module Regexp::Syntax
       implements :anchor, Anchor::All
       implements :assertion, Assertion::Lookahead
       implements :backref, [:number]
-
+      implements :posixclass, PosixClass::Standard
       implements :escape,
         Escape::Basic + Escape::Backreference +
         Escape::ASCII + Escape::Meta + Escape::Control
@@ -19,9 +19,7 @@ module Regexp::Syntax
         Quantifier::Greedy + Quantifier::Reluctant +
         Quantifier::Interval + Quantifier::IntervalReluctant
 
-      implements :set, CharacterSet::OpenClose +
-        CharacterSet::Extended + CharacterSet::Types +
-        CharacterSet::POSIX::Standard
+      implements :set, CharacterSet::OpenClose + CharacterSet::Extended
 
       implements :type,
         CharacterType::Extended

data/lib/regexp_parser/syntax/versions/1.9.1.rb

@@ -9,6 +9,10 @@ module Regexp::Syntax
       implements :backref, Backreference::All +
         SubexpressionCall::All
 
+      implements :posixclass, PosixClass::Extensions
+
+      implements :nonposixclass, PosixClass::All
+
       implements :escape, Escape::Unicode + Escape::Hex + Escape::Octal
 
       implements :type, CharacterType::Hex
@@ -21,16 +25,6 @@ module Regexp::Syntax
 
       implements :quantifier,
         Quantifier::Possessive + Quantifier::IntervalPossessive
-
-      implements :set,
-        CharacterSet::POSIX::StandardNegative +
-        CharacterSet::POSIX::Extensions +
-        CharacterSet::POSIX::ExtensionsNegative +
-        UnicodeProperty::V1_9_0
-
-      implements :subset, CharacterSet::OpenClose +
-        CharacterSet::Extended + CharacterSet::Types +
-        CharacterSet::POSIX::Standard
     end
   end
 end

data/lib/regexp_parser/syntax/versions/2.0.0.rb

@@ -10,8 +10,6 @@ module Regexp::Syntax
       implements :nonproperty, UnicodeProperty::V2_0_0
 
       implements :type,        CharacterType::Clustered
-      implements :set,         CharacterSet::Clustered
-      implements :subset,      CharacterSet::Clustered
 
       excludes   :property,    :newline
       excludes   :nonproperty, :newline

data/lib/regexp_parser/syntax/versions/2.4.1.rb

@@ -3,7 +3,7 @@ module Regexp::Syntax
     def initialize
       super
 
-      implements :group, Group::Absence
+      implements :group, Group::V2_4_1
     end
   end
 end

data/lib/regexp_parser/version.rb

@@ -1,5 +1,5 @@
 class Regexp
   class Parser
-    VERSION = '0.5.0'
+    VERSION = '1.0.0'
   end
 end

data/regexp_parser.gemspec

@@ -23,7 +23,8 @@ Gem::Specification.new do |gem|
 
   gem.files         = Dir.glob('{lib,test}/**/*.rb') +
                       Dir.glob('lib/**/*.rl') +
-                      %w(Gemfile Rakefile LICENSE README.md ChangeLog regexp_parser.gemspec)
+                      Dir.glob('lib/**/*.yml') +
+                      %w(Gemfile Rakefile LICENSE README.md CHANGELOG.md regexp_parser.gemspec)
 
   gem.test_files    = Dir.glob('test/**/*.rb')
 

data/test/expression/test_base.rb

@@ -40,7 +40,8 @@ class ExpressionBase < Test::Unit::TestCase
     assert_equal true,  root[0].terminal?
     assert_equal true,  root[1].terminal?
     assert_equal false, root[2].terminal?
-    assert_equal true,  root[2][0].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

data/test/expression/test_clone.rb

@@ -86,61 +86,4 @@ class ExpressionClone < Test::Unit::TestCase
     end
   end
 
-  def test_expression_clone_set
-    root = RP.parse(/^a(b([cde])f)g$/)
-    copy = root.clone
-
-    root_2_1 = root.expressions[2][1]
-
-    copy.expressions[2][1].each_with_index do |exp, index|
-      assert exp.respond_to?(:members)
-
-      # The members arrays are not equal.
-      refute_equal exp.members.object_id,
-                   root_2_1[index].members.object_id
-
-      # The members in the arrays are not equal.
-      exp.members.each_with_index do |member, member_index|
-        refute_equal member.object_id,
-                     root_2_1[index].members[member_index].object_id
-      end
-    end
-  end
-
-  def test_expression_clone_subset
-    # Explicitly set syntax to ruby 1.9 because 1.8 does not
-    # implement subsets.
-    root = RP.parse('^a(b([c[def]g])h)i$', 'ruby/1.9')
-    copy = root.clone
-
-    root_set    = root.expressions[2][1][0]
-    copy_set    = copy.expressions[2][1][0]
-
-    root_subset = root_set.members[1]
-    copy_subset = copy_set.members[1]
-
-    # Sanity checks
-    assert root_set.respond_to?(:members)
-    assert copy_set.respond_to?(:members)
-
-    assert root_subset.respond_to?(:members)
-    assert copy_subset.respond_to?(:members)
-
-    # The sets are not equal
-    refute_equal copy_set.object_id, root_set.object_id
-
-    # The subsets are not equal
-    refute_equal copy_subset.object_id, root_subset.object_id
-
-    # The subsets' members arrays are not equal.
-    refute_equal copy_subset.members.object_id,
-                 root_subset.members.object_id
-
-    # The subsets' members are not equal
-    copy_subset.members.each_with_index do |member, member_index|
-      refute_equal member.object_id,
-                   root_subset.members[member_index].object_id
-    end
-  end
-
 end

data/test/expression/test_set.rb

@@ -2,60 +2,83 @@ require File.expand_path("../../helpers", __FILE__)
 
 class ExpressionSet < Test::Unit::TestCase
 
-  def test_expression_set_exapnd_members_digit
+  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_exapnd_members_nondigit
+  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_exapnd_members_word
+  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_exapnd_members_nonword
+  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_exapnd_members_space
+  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_exapnd_members_nonspace
+  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_exapnd_members_xdigit
+  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_exapnd_members_nonxdigit
+  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

@@ -151,7 +151,7 @@ class Expressionstrfregexp < Test::Unit::TestCase
     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')
+    assert_equal 'set:character', set.strfregexp('%~t')
   end
 
   def test_expression_strfregexp_combined
@@ -180,7 +180,10 @@ class Expressionstrfregexp < Test::Unit::TestCase
     assert_equal(
       "@0+15 expression:root\n" +
       "  @0+1 a\n" +
-      "  @1+6 [b-d]*\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" +
@@ -195,7 +198,10 @@ class Expressionstrfregexp < Test::Unit::TestCase
     assert_equal(
       "@0+15 expression:root-SEP-" +
       "  @0+1 a-SEP-" +
-      "  @1+6 [b-d]*-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-" +
@@ -209,7 +215,10 @@ class Expressionstrfregexp < Test::Unit::TestCase
 
     assert_equal(
       "@0+1 a\n" +
-      "@1+6 [b-d]*\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" +

data/test/expression/test_subexpression.rb

@@ -21,4 +21,29 @@ class ExpressionSubexpression < Test::Unit::TestCase
     end
   end
 
+  def test_subexpression_nesting_level
+    root = RP.parse(/a(b(c\d|[ef-g[h]]))/)
+
+    tests = {
+      'a'         => 1,
+      'b'         => 2,
+      '|'         => 3,
+      'c\d'       => 4, # first alternative
+      'c'         => 5,
+      '\d'        => 5,
+      '[ef-g[h]]' => 4, # second alternative
+      'e'         => 5,
+      '-'         => 5,
+      'f'         => 6,
+      'g'         => 6,
+      'h'         => 6,
+    }
+
+    root.each_expression do |exp|
+      next unless (expected_nesting_level = tests.delete(exp.text))
+      assert_equal exp.nesting_level, expected_nesting_level
+    end
+
+    assert tests.empty?
+  end
 end

data/test/expression/test_traverse.rb

@@ -3,7 +3,7 @@ require File.expand_path("../../helpers", __FILE__)
 class SubexpressionTraverse < Test::Unit::TestCase
 
   def test_subexpression_traverse
-    root = RP.parse(/a(b(c(d)))|g[hi]j|klmn/)
+    root = RP.parse(/a(b(c(d)))|g[h-i]j|klmn/)
 
     enters = 0
     visits = 0
@@ -15,14 +15,14 @@ class SubexpressionTraverse < Test::Unit::TestCase
       exits  += 1 if event == :exit
     }
 
-    assert_equal 7,     enters
+    assert_equal 9,     enters
     assert_equal exits, enters
 
-    assert_equal 8, visits
+    assert_equal 9, visits
   end
 
   def test_subexpression_traverse_include_self
-    root = RP.parse(/a(b(c(d)))|g[hi]j|klmn/)
+    root = RP.parse(/a(b(c(d)))|g[h-i]j|klmn/)
 
     enters = 0
     visits = 0
@@ -34,10 +34,10 @@ class SubexpressionTraverse < Test::Unit::TestCase
       exits  += 1 if event == :exit
     }
 
-    assert_equal 8,     enters
+    assert_equal 10,    enters
     assert_equal exits, enters
 
-    assert_equal 8, visits
+    assert_equal 9, visits
   end
 
   def test_subexpression_walk_alias
@@ -54,18 +54,18 @@ class SubexpressionTraverse < Test::Unit::TestCase
       count += 1
     }
 
-    assert_equal 10, count
+    assert_equal 13, count
   end
 
   def test_subexpression_each_expression_include_self
-    root = RP.parse(/a(?x:b(c))|g[hi]/)
+    root = RP.parse(/a(?x:b(c))|g[h-k]/)
 
     count = 0
     root.each_expression(true) {|exp, index|
       count += 1
     }
 
-    assert_equal 11, count
+    assert_equal 14, count
   end
 
   def test_subexpression_each_expression_indices
@@ -86,13 +86,13 @@ class SubexpressionTraverse < Test::Unit::TestCase
     assert_equal [0, 0, 1, 0, 2], indices
   end
 
-  def test_subexpression_map_without_block
+  def test_subexpression_flat_map_without_block
     root = RP.parse(/a(b([c-e]+))?/)
 
-    array = root.map
+    array = root.flat_map
 
     assert_equal Array, array.class
-    assert_equal 5, array.length
+    assert_equal 8, array.length
 
     array.each do |item|
       assert_equal Array, item.class
@@ -102,35 +102,35 @@ class SubexpressionTraverse < Test::Unit::TestCase
     end
   end
 
-  def test_subexpression_map_without_block_include_self
+  def test_subexpression_flat_map_without_block_include_self
     root = RP.parse(/a(b([c-e]+))?/)
 
-    array = root.map(true)
+    array = root.flat_map(true)
 
     assert_equal Array, array.class
-    assert_equal 6, array.length
+    assert_equal 9, array.length
   end
 
-  def test_subexpression_map_indices
+  def test_subexpression_flat_map_indices
     root = RP.parse(/a(b([c-e]+))?f*g/)
 
-    indices = root.map {|exp, index| index}
+    indices = root.flat_map {|exp, index| index}
 
-    assert_equal [0, 1, 0, 1, 0, 2, 3], indices
+    assert_equal [0, 1, 0, 1, 0, 0, 0, 1, 2, 3], indices
   end
 
-  def test_subexpression_map_indices_include_self
+  def test_subexpression_flat_map_indices_include_self
     root = RP.parse(/a(b([c-e]+))?f*g/)
 
-    indices = root.map(true) {|exp, index| index}
+    indices = root.flat_map(true) {|exp, index| index}
 
-    assert_equal [0, 0, 1, 0, 1, 0, 2, 3], indices
+    assert_equal [0, 0, 1, 0, 1, 0, 0, 0, 1, 2, 3], indices
   end
 
-  def test_subexpression_map_expressions
+  def test_subexpression_flat_map_expressions
     root = RP.parse(/a(b(c(d)))/)
 
-    levels = root.map {|exp, index|
+    levels = root.flat_map {|exp, index|
       [exp.level, exp.text] if exp.terminal?
     }.compact
 
@@ -139,10 +139,10 @@ class SubexpressionTraverse < Test::Unit::TestCase
       ], levels
   end
 
-  def test_subexpression_map_expressions_include_self
+  def test_subexpression_flat_map_expressions_include_self
     root = RP.parse(/a(b(c(d)))/)
 
-    levels = root.map(true) {|exp, index|
+    levels = root.flat_map(true) {|exp, index|
       [exp.level, exp.to_s]
     }.compact