regexp_parser 1.4.0 → 1.5.0

data/{test/scanner/test_escapes.rb → spec/scanner/escapes_spec.rb}

@@ -1,7 +1,6 @@
-require File.expand_path("../../helpers", __FILE__)
-
-class ScannerEscapes < Test::Unit::TestCase
+require 'spec_helper'
 
+RSpec.describe('Escape scanning') do
   tests = {
     /c\at/            => [1, :escape,  :bell,             '\a',             1,  3],
 
@@ -41,16 +40,15 @@ class ScannerEscapes < Test::Unit::TestCase
   }
 
   tests.each_with_index do |(pattern, (index, type, token, text, ts, te)), count|
-    define_method "test_scanner_#{type}_#{token}_#{count}" do
+    specify("scanner_#{type}_#{token}_#{count}") do
       tokens = RS.scan(pattern)
       result = tokens.at(index)
 
-      assert_equal type,  result[0]
-      assert_equal token, result[1]
-      assert_equal text,  result[2]
-      assert_equal ts,    result[3]
-      assert_equal te,    result[4]
+      expect(result[0]).to eq type
+      expect(result[1]).to eq token
+      expect(result[2]).to eq text
+      expect(result[3]).to eq ts
+      expect(result[4]).to eq te
     end
   end
-
 end

data/{test/scanner/test_free_space.rb → spec/scanner/free_space_spec.rb}

@@ -1,43 +1,38 @@
-require File.expand_path("../../helpers", __FILE__)
+require 'spec_helper'
 
-class ScannerFreeSpace < Test::Unit::TestCase
-
-  def test_scan_free_space_tokens
-    regexp = %r{
+RSpec.describe('FreeSpace scanning') do
+  specify('scan free space tokens') do
+    regexp = /
       a
       b  ?  c  *
       d  {2,3}
       e + | f +
-    }x
+    /x
 
     tokens = RS.scan(regexp)
 
     0.upto(24) do |i|
       if i.even?
-        assert_equal :free_space, tokens[i][0]
-        assert_equal :whitespace, tokens[i][1]
+        expect(tokens[i][0]).to eq :free_space
+        expect(tokens[i][1]).to eq :whitespace
       else
-        refute_equal :free_space, tokens[i][0]
-        refute_equal :whitespace, tokens[i][1]
+        expect(tokens[i][0]).not_to eq :free_space
+        expect(tokens[i][1]).not_to eq :whitespace
       end
     end
 
-    [0, 2, 10, 14].each do |i|
-      assert_equal "\n      ",   tokens[i][2]
-    end
+    [0, 2, 10, 14].each { |i| expect(tokens[i][2]).to eq "\n      " }
 
-    [4, 6, 8, 12].each do |i|
-      assert_equal '  ',         tokens[i][2]
-    end
+    [4, 6, 8, 12].each { |i| expect(tokens[i][2]).to eq '  ' }
   end
 
-  def test_scan_free_space_comments
-    regexp = %r{
+  specify('scan free space comments') do
+    regexp = /
       a + # A + comment
       b  ?  # B ? comment
       c  {2,3} # C {2,3} comment
       d + | e + # D|E comment
-    }x
+    /x
 
     tokens = RS.scan(regexp)
 
@@ -49,17 +44,17 @@ class ScannerFreeSpace < Test::Unit::TestCase
     ].each do |index, type, token, text, ts, te|
       result = tokens[index]
 
-      assert_equal type,  result[0]
-      assert_equal token, result[1]
-      assert_equal text,  result[2]
-      assert_equal ts,    result[3]
-      assert_equal te,    result[4]
+      expect(result[0]).to eq type
+      expect(result[1]).to eq token
+      expect(result[2]).to eq text
+      expect(result[3]).to eq ts
+      expect(result[4]).to eq te
     end
   end
 
-  def test_scan_free_space_inlined
-    # Matches 'a bcdef g'
+  specify('scan free space inlined') do
     regexp = /a b(?x:c d e)f g/
+
     tokens = RS.scan(regexp)
 
     [
@@ -75,17 +70,17 @@ class ScannerFreeSpace < Test::Unit::TestCase
     ].each do |index, type, token, text, ts, te|
       result = tokens[index]
 
-      assert_equal type,  result[0]
-      assert_equal token, result[1]
-      assert_equal text,  result[2]
-      assert_equal ts,    result[3]
-      assert_equal te,    result[4]
+      expect(result[0]).to eq type
+      expect(result[1]).to eq token
+      expect(result[2]).to eq text
+      expect(result[3]).to eq ts
+      expect(result[4]).to eq te
     end
   end
 
-  def test_scan_free_space_nested
-    # Matches 'a bcde fghi j'
+  specify('scan free space nested') do
     regexp = /a b(?x:c d(?-x:e f)g h)i j/
+
     tokens = RS.scan(regexp)
 
     [
@@ -105,17 +100,17 @@ class ScannerFreeSpace < Test::Unit::TestCase
     ].each do |index, type, token, text, ts, te|
       result = tokens[index]
 
-      assert_equal type,  result[0]
-      assert_equal token, result[1]
-      assert_equal text,  result[2]
-      assert_equal ts,    result[3]
-      assert_equal te,    result[4]
+      expect(result[0]).to eq type
+      expect(result[1]).to eq token
+      expect(result[2]).to eq text
+      expect(result[3]).to eq ts
+      expect(result[4]).to eq te
     end
   end
 
-  def test_scan_free_space_nested_groups
-    # Matches 'a bcde f g hi j'
+  specify('scan free space nested groups') do
     regexp = /(a (b(?x: (c d) (?-x:(e f) )g) h)i j)/
+
     tokens = RS.scan(regexp)
 
     [
@@ -146,18 +141,19 @@ class ScannerFreeSpace < Test::Unit::TestCase
     ].each do |index, type, token, text, ts, te|
       result = tokens[index]
 
-      assert_equal type,  result[0]
-      assert_equal token, result[1]
-      assert_equal text,  result[2]
-      assert_equal ts,    result[3]
-      assert_equal te,    result[4]
+      expect(result[0]).to eq type
+      expect(result[1]).to eq token
+      expect(result[2]).to eq text
+      expect(result[3]).to eq ts
+      expect(result[4]).to eq te
     end
   end
 
-  def test_scan_free_space_switch_groups
-    # Matches 'a bcde f g hi j'
+  specify('scan free space switch groups') do
     regexp = /(a (b((?x) (c d) ((?-x)(e f) )g) h)i j)/
+
     tokens = RS.scan(regexp)
+
     [
       [ 0, :group,      :capture,        '(',     0,  1],
       [ 1, :literal,    :literal,        'a ',    1,  3],
@@ -190,11 +186,11 @@ class ScannerFreeSpace < Test::Unit::TestCase
     ].each do |index, type, token, text, ts, te|
       result = tokens[index]
 
-      assert_equal type,  result[0]
-      assert_equal token, result[1]
-      assert_equal text,  result[2]
-      assert_equal ts,    result[3]
-      assert_equal te,    result[4]
+      expect(result[0]).to eq type
+      expect(result[1]).to eq token
+      expect(result[2]).to eq text
+      expect(result[3]).to eq ts
+      expect(result[4]).to eq te
     end
   end
 end

data/{test/scanner/test_groups.rb → spec/scanner/groups_spec.rb}

@@ -1,18 +1,7 @@
-require File.expand_path("../../helpers", __FILE__)
-
-class ScannerGroups < Test::Unit::TestCase
+require 'spec_helper'
 
+RSpec.describe('Group scanning') do
   tests = {
-    # Options
-    '(?-mix:abc)'     => [0, :group,     :options,        '(?-mix:',    0, 7],
-    '(?m-ix:abc)'     => [0, :group,     :options,        '(?m-ix:',    0, 7],
-    '(?mi-x:abc)'     => [0, :group,     :options,        '(?mi-x:',    0, 7],
-    '(?mix:abc)'      => [0, :group,     :options,        '(?mix:',     0, 6],
-    '(?m:)'           => [0, :group,     :options,        '(?m:',       0, 4],
-    '(?i:)'           => [0, :group,     :options,        '(?i:',       0, 4],
-    '(?x:)'           => [0, :group,     :options,        '(?x:',       0, 4],
-    '(?mix)'          => [0, :group,     :options_switch, '(?mix',      0, 5],
-
     # Group types
     '(?>abc)'         => [0, :group,     :atomic,         '(?>',        0, 3],
     '(abc)'           => [0, :group,     :capture,        '(',          0, 1],
@@ -36,44 +25,47 @@ class ScannerGroups < Test::Unit::TestCase
     '(?!abc)'         => [0, :assertion, :nlookahead,     '(?!',        0, 3],
     '(?<=abc)'        => [0, :assertion, :lookbehind,     '(?<=',       0, 4],
     '(?<!abc)'        => [0, :assertion, :nlookbehind,    '(?<!',       0, 4],
-  }
 
-  if RUBY_VERSION >= '2.0'
-    tests.merge!({
-      # New options
-      '(?d-mix:abc)'  => [0, :group,     :options,        '(?d-mix:',   0, 8],
-      '(?a-mix:abc)'  => [0, :group,     :options,        '(?a-mix:',   0, 8],
-      '(?u-mix:abc)'  => [0, :group,     :options,        '(?u-mix:',   0, 8],
-      '(?da-m:abc)'   => [0, :group,     :options,        '(?da-m:',    0, 7],
-      '(?du-x:abc)'   => [0, :group,     :options,        '(?du-x:',    0, 7],
-      '(?dau-i:abc)'  => [0, :group,     :options,        '(?dau-i:',   0, 8],
-      '(?dau:abc)'    => [0, :group,     :options,        '(?dau:',     0, 6],
-      '(?d:)'         => [0, :group,     :options,        '(?d:',       0, 4],
-      '(?a:)'         => [0, :group,     :options,        '(?a:',       0, 4],
-      '(?u:)'         => [0, :group,     :options,        '(?u:',       0, 4],
-      '(?dau)'        => [0, :group,     :options_switch, '(?dau',      0, 5],
-    })
-  end
+    # Options
+    '(?-mix:abc)'     => [0, :group,     :options,        '(?-mix:',    0, 7],
+    '(?m-ix:abc)'     => [0, :group,     :options,        '(?m-ix:',    0, 7],
+    '(?mi-x:abc)'     => [0, :group,     :options,        '(?mi-x:',    0, 7],
+    '(?mix:abc)'      => [0, :group,     :options,        '(?mix:',     0, 6],
+    '(?m:)'           => [0, :group,     :options,        '(?m:',       0, 4],
+    '(?i:)'           => [0, :group,     :options,        '(?i:',       0, 4],
+    '(?x:)'           => [0, :group,     :options,        '(?x:',       0, 4],
+    '(?mix)'          => [0, :group,     :options_switch, '(?mix',      0, 5],
+    '(?d-mix:abc)'    => [0, :group,     :options,        '(?d-mix:',   0, 8],
+    '(?a-mix:abc)'    => [0, :group,     :options,        '(?a-mix:',   0, 8],
+    '(?u-mix:abc)'    => [0, :group,     :options,        '(?u-mix:',   0, 8],
+    '(?da-m:abc)'     => [0, :group,     :options,        '(?da-m:',    0, 7],
+    '(?du-x:abc)'     => [0, :group,     :options,        '(?du-x:',    0, 7],
+    '(?dau-i:abc)'    => [0, :group,     :options,        '(?dau-i:',   0, 8],
+    '(?dau:abc)'      => [0, :group,     :options,        '(?dau:',     0, 6],
+    '(?d:)'           => [0, :group,     :options,        '(?d:',       0, 4],
+    '(?a:)'           => [0, :group,     :options,        '(?a:',       0, 4],
+    '(?u:)'           => [0, :group,     :options,        '(?u:',       0, 4],
+    '(?dau)'          => [0, :group,     :options_switch, '(?dau',      0, 5],
+  }
 
-  if RUBY_VERSION >= '2.4.1'
-    tests.merge!({
+  if ruby_version_at_least('2.4.1')
+    tests.merge!(
       # New absence operator
       '(?~abc)'       => [0, :group,     :absence,        '(?~',        0, 3],
-    })
+    )
   end
 
   tests.each_with_index do |(pattern, (index, type, token, text, ts, te)), count|
-    define_method "test_scanner_#{type}_#{token}_#{count}" do
+    specify("scanner_#{type}_#{token}_#{count}") do
       tokens = RS.scan(pattern)
       result = tokens[index]
 
-      assert_equal type,  result[0]
-      assert_equal token, result[1]
-      assert_equal text,  result[2]
-      assert_equal ts,    result[3]
-      assert_equal te,    result[4]
-      assert_equal text,  pattern[ts, te]
+      expect(result[0]).to eq type
+      expect(result[1]).to eq token
+      expect(result[2]).to eq text
+      expect(result[3]).to eq ts
+      expect(result[4]).to eq te
+      expect(pattern[ts, te]).to eq text
     end
   end
-
 end

data/spec/scanner/keep_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+RSpec.describe('Keep scanning') do
+  specify('scan keep token') do
+    tokens = RS.scan(/ab\Kcd/)
+    result = tokens.at(1)
+
+    expect(result[0]).to eq :keep
+    expect(result[1]).to eq :mark
+    expect(result[2]).to eq '\\K'
+    expect(result[3]).to eq 2
+    expect(result[4]).to eq 4
+  end
+
+  specify('scan keep nested') do
+    tokens = RS.scan(/(a\Kb)|(c\\\Kd)ef/)
+
+    first = tokens.at(2)
+    second = tokens.at(9)
+
+    expect(first[0]).to eq :keep
+    expect(first[1]).to eq :mark
+    expect(first[2]).to eq '\\K'
+    expect(first[3]).to eq 2
+    expect(first[4]).to eq 4
+
+    expect(second[0]).to eq :keep
+    expect(second[1]).to eq :mark
+    expect(second[2]).to eq '\\K'
+    expect(second[3]).to eq 11
+    expect(second[4]).to eq 13
+  end
+end

data/{test/scanner/test_literals.rb → spec/scanner/literals_spec.rb}

@@ -1,9 +1,6 @@
-# -*- encoding: utf-8 -*-
-
-require File.expand_path("../../helpers", __FILE__)
-
-class ScannerUTF8 < Test::Unit::TestCase
+require 'spec_helper'
 
+RSpec.describe('UTF8 scanning') do
   tests = {
     # ascii, single byte characters
     'a' => {
@@ -71,19 +68,18 @@ class ScannerUTF8 < Test::Unit::TestCase
   }
 
   tests.each_with_index do |(pattern, checks), count|
-    define_method "test_scanner_utf8_runs_#{count}" do
+    specify("scanner_utf8_runs_#{count}") do
       tokens = RS.scan(pattern)
 
       checks.each do |index, (type, token, text, ts, te)|
         result = tokens[index]
 
-        assert_equal type,  result[0]
-        assert_equal token, result[1]
-        assert_equal text,  result[2]
-        assert_equal ts,    result[3]
-        assert_equal te,    result[4]
+        expect(result[0]).to eq type
+        expect(result[1]).to eq token
+        expect(result[2]).to eq text
+        expect(result[3]).to eq ts
+        expect(result[4]).to eq te
       end
     end
   end
-
 end

data/{test/scanner/test_meta.rb → spec/scanner/meta_spec.rb}

@@ -1,7 +1,6 @@
-require File.expand_path("../../helpers", __FILE__)
-
-class ScannerMeta < Test::Unit::TestCase
+require 'spec_helper'
 
+RSpec.describe('Meta scanning') do
   tests = {
     'abc??|def*+|ghi+' => {
       0   => [:literal,     :literal,                 'abc',  0, 3],
@@ -22,19 +21,18 @@ class ScannerMeta < Test::Unit::TestCase
   }
 
   tests.each_with_index do |(pattern, checks), count|
-    define_method "test_scanner_meta_alternation_#{count}" do
+    specify("scanner_meta_alternation_#{count}") do
       tokens = RS.scan(pattern)
 
       checks.each do |index, (type, token, text, ts, te)|
         result = tokens.at(index)
 
-        assert_equal type,  result[0]
-        assert_equal token, result[1]
-        assert_equal text,  result[2]
-        assert_equal ts,    result[3]
-        assert_equal te,    result[4]
+        expect(result[0]).to eq type
+        expect(result[1]).to eq token
+        expect(result[2]).to eq text
+        expect(result[3]).to eq ts
+        expect(result[4]).to eq te
       end
     end
   end
-
 end

data/{test/scanner/test_properties.rb → spec/scanner/properties_spec.rb}

@@ -1,7 +1,6 @@
-require File.expand_path("../../helpers", __FILE__)
-
-class ScannerProperties < Test::Unit::TestCase
+require 'spec_helper'
 
+RSpec.describe('Property scanning') do
   tests = {
     'Alnum'                               => :alnum,
 
@@ -277,36 +276,32 @@ class ScannerProperties < Test::Unit::TestCase
   }
 
   tests.each_with_index do |(property, token), count|
-    define_method "test_scan_property_#{token}_#{count}" do
+    specify("scan_property_#{token}_#{count}") do
       tokens = RS.scan("a\\p{#{property}}c")
       result = tokens.at(1)
-
-      assert_equal :property, result[0]
-      assert_equal token,     result[1]
+      expect(result[0]).to eq :property
+      expect(result[1]).to eq token
     end
 
-    define_method "test_scan_nonproperty_#{token}_#{count}" do
+    specify("scan_nonproperty_#{token}_#{count}") do
       tokens = RS.scan("a\\P{#{property}}c")
       result = tokens.at(1)
-
-      assert_equal :nonproperty, result[0]
-      assert_equal token,        result[1]
+      expect(result[0]).to eq :nonproperty
+      expect(result[1]).to eq token
     end
 
-    define_method "test_scan_caret_nonproperty_#{token}_#{count}" do
+    specify("scan_caret_nonproperty_#{token}_#{count}") do
       tokens = RS.scan("a\\p{^#{property}}c")
       result = tokens.at(1)
-
-      assert_equal :nonproperty, result[0]
-      assert_equal token,        result[1]
+      expect(result[0]).to eq :nonproperty
+      expect(result[1]).to eq token
     end
 
-    define_method "test_scan_double_negated_property_#{token}_#{count}" do
+    specify("scan_double_negated_property_#{token}_#{count}") do
       tokens = RS.scan("a\\P{^#{property}}c")
       result = tokens.at(1)
-
-      assert_equal :property, result[0]
-      assert_equal token,     result[1]
+      expect(result[0]).to eq :property
+      expect(result[1]).to eq token
     end
   end
 end