regexp_parser 1.4.0 → 1.5.0

data/{test/scanner/test_quantifiers.rb → spec/scanner/quantifiers_spec.rb}

@@ -1,7 +1,6 @@
-require File.expand_path("../../helpers", __FILE__)
-
-class ScannerQuantifiers < Test::Unit::TestCase
+require 'spec_helper'
 
+RSpec.describe('Quantifier scanning') do
   tests = {
    'a?'     => [:quantifier,  :zero_or_one,             '?'],
    'a??'    => [:quantifier,  :zero_or_one_reluctant,   '??'],
@@ -22,16 +21,15 @@ class ScannerQuantifiers < Test::Unit::TestCase
   }
 
   tests.each_with_index do |(pattern, (type, token, text)), count|
-    name = (token == :interval ? "interval_#{count}" : token)
+    name = token == :interval ? "interval_#{count}" : token
 
-    define_method "test_scan_#{type}_#{name}" do
+    specify("scan_#{type}_#{name}") do
       tokens = RS.scan(pattern)
       result = tokens.last
 
-      assert_equal type,  result[0]
-      assert_equal token, result[1]
-      assert_equal text,  result[2]
+      expect(result[0]).to eq type
+      expect(result[1]).to eq token
+      expect(result[2]).to eq text
     end
   end
-
 end

data/{test/scanner/test_refcalls.rb → spec/scanner/refcalls_spec.rb}

@@ -1,6 +1,6 @@
-require File.expand_path("../../helpers", __FILE__)
+require 'spec_helper'
 
-class ScannerRefCalls < Test::Unit::TestCase
+RSpec.describe('RefCall scanning') do
   tests = {
     # Traditional numerical group back-reference
     '(abc)\1'           => [3, :backref, :number,                  '\1',         5, 7],
@@ -37,16 +37,16 @@ class ScannerRefCalls < 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[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/{test/scanner/test_scripts.rb → spec/scanner/scripts_spec.rb}

@@ -1,7 +1,6 @@
-require File.expand_path("../../helpers", __FILE__)
-
-class ScannerUnicodeScripts < Test::Unit::TestCase
+require 'spec_helper'
 
+RSpec.describe('UnicodeScript scanning') do
   tests = {
     'Aghb'	                  => :caucasian_albanian,
     'Caucasian Albanian'	    => :caucasian_albanian,
@@ -33,21 +32,18 @@ class ScannerUnicodeScripts < Test::Unit::TestCase
   }
 
   tests.each_with_index do |(property, token), count|
-    define_method "test_scanner_property_#{token}_#{count}" do
+    specify("scanner_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_scanner_nonproperty_#{token}_#{count}" do
+    specify("scanner_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
   end
-
 end

data/{test/scanner/test_sets.rb → spec/scanner/sets_spec.rb}

@@ -1,9 +1,6 @@
-# encoding: utf-8
-
-require File.expand_path("../../helpers", __FILE__)
-
-class ScannerSets < Test::Unit::TestCase
+require 'spec_helper'
 
+RSpec.describe('Set scanning') do
   tests = {
     '[a]'                   => [0, :set,    :open,            '[',          0, 1],
     '[b]'                   => [2, :set,    :close,           ']',          2, 3],
@@ -95,25 +92,25 @@ class ScannerSets < Test::Unit::TestCase
   }
 
   tests.each_with_index do |(pattern, (index, type, token, text, ts, te)), count|
-    define_method "test_scanner_#{type}_#{token}_in_'#{pattern}'_#{count}" do
+    specify("scanner_#{type}_#{token}_in_'#{pattern}'_#{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
 
-  def test_set_literal_encoding
+  specify('set literal encoding') do
     text = RS.scan('[a]')[1][2].to_s
-    assert_equal 'a',     text
-    assert_equal 'UTF-8', text.encoding.to_s
+    expect(text).to eq 'a'
+    expect(text.encoding.to_s).to eq 'UTF-8'
 
-    text = RS.scan('[😲]')[1][2].to_s
-    assert_equal '😲',     text
-    assert_equal 'UTF-8', text.encoding.to_s
+    text = RS.scan("[\u{1F632}]")[1][2].to_s
+    expect(text).to eq "\u{1F632}"
+    expect(text.encoding.to_s).to eq 'UTF-8'
   end
 end

data/spec/scanner/types_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+RSpec.describe('Type scanning') do
+  tests = {
+    'a\\dc' => [1, :type, :digit, '\\d', 1, 3],
+    'a\\Dc' => [1, :type, :nondigit, '\\D', 1, 3],
+    'a\\hc' => [1, :type, :hex, '\\h', 1, 3],
+    'a\\Hc' => [1, :type, :nonhex, '\\H', 1, 3],
+    'a\\sc' => [1, :type, :space, '\\s', 1, 3],
+    'a\\Sc' => [1, :type, :nonspace, '\\S', 1, 3],
+    'a\\wc' => [1, :type, :word, '\\w', 1, 3],
+    'a\\Wc' => [1, :type, :nonword, '\\W', 1, 3],
+    'a\\Rc' => [1, :type, :linebreak, '\\R', 1, 3],
+    'a\\Xc' => [1, :type, :xgrapheme, '\\X', 1, 3],
+  }
+
+  tests.each do |(pattern, (index, type, token, text, ts, te))|
+    specify("scanner_#{type}_#{token}") do
+      tokens = RS.scan(pattern)
+      result = tokens.at(index)
+
+      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/spec/scanner/unicode_blocks_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+RSpec.describe('UnicodeBlock scanning') do
+  tests = {
+    'InArabic'                               => :in_arabic,
+    'InCJK_Unified_Ideographs_Extension_A'   => :in_cjk_unified_ideographs_extension_a,
+    'In Letterlike Symbols'                  => :in_letterlike_symbols,
+    'InMiscellaneous_Mathematical_Symbols-A' => :in_miscellaneous_mathematical_symbols_a
+  }
+
+  tests.each_with_index do |(property, token), count|
+    specify("scanner_property_#{token}_#{count}") do
+      tokens = RS.scan("a\\p{#{property}}c")
+      result = tokens.at(1)
+
+      expect(result[0]).to eq :property
+      expect(result[1]).to eq token
+    end
+
+    specify("scanner_nonproperty_#{token}_#{count}") do
+      tokens = RS.scan("a\\P{#{property}}c")
+      result = tokens.at(1)
+
+      expect(result[0]).to eq :nonproperty
+      expect(result[1]).to eq token
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,14 @@
+require 'regexp_parser'
+require 'regexp_property_values'
+
+RS = Regexp::Scanner
+RL = Regexp::Lexer
+RP = Regexp::Parser
+RE = Regexp::Expression
+T = Regexp::Syntax::Token
+
+include Regexp::Expression
+
+def ruby_version_at_least(version)
+  Gem::Version.new(RUBY_VERSION.dup) >= Gem::Version.new(version)
+end

data/{test → spec}/support/runner.rb

@@ -1,6 +1,7 @@
 require 'pathname'
+require 'rspec'
 
-module RegexpParserTest
+module RegexpParserSpec
   class Runner
     def initialize(arguments, warning_whitelist)
       @arguments = arguments
@@ -8,14 +9,14 @@ module RegexpParserTest
     end
 
     def run
-      test_status = nil
+      spec_status = nil
 
       Warning::Filter.new(warning_whitelist).assert_expected_warnings_only do
         setup
-        test_status = run_test_unit
+        spec_status = run_rspec
       end
 
-      test_status
+      spec_status
     end
 
     private
@@ -23,14 +24,14 @@ module RegexpParserTest
     def setup
       $VERBOSE = true
 
-      test_files.each(&method(:require))
+      spec_files.each(&method(:require))
     end
 
-    def run_test_unit
-      Test::Unit::AutoRunner.run
+    def run_rspec
+      RSpec::Core::Runner.run([])
     end
 
-    def test_files
+    def spec_files
       arguments
         .map { |path| Pathname.new(path).expand_path.freeze }
         .select(&:file?)

data/{test → spec}/support/warning_extractor.rb

@@ -1,7 +1,7 @@
 require 'set'
 require 'delegate'
 
-module RegexpParserTest
+module RegexpParserSpec
   class Warning
     class UnexpectedWarnings < StandardError
       MSG = 'Unexpected warnings: %s'.freeze
@@ -22,22 +22,20 @@ module RegexpParserTest
 
         yield
 
-        if Gem::Version.new(RUBY_VERSION.dup) >= Gem::Version.new('2.0.0')
-          assert_no_warnings($stderr.warnings)
-        end
+        assert_no_warnings($stderr.warnings)
       ensure
         $stderr = original
       end
 
-    private
+      private
 
       def assert_no_warnings(warnings)
-        fail UnexpectedWarnings, warnings.to_a if warnings.any?
+        raise UnexpectedWarnings, warnings.to_a if warnings.any?
       end
     end
 
     class Extractor < DelegateClass(IO)
-      PATTERN = /\A(?:.+):(?:\d+): warning: (?:.+)\n\z/.freeze
+      PATTERN = /\A(?:.+):(?:\d+): warning: (?:.+)\n\z/
 
       def initialize(io, whitelist)
         @whitelist = whitelist

data/spec/syntax/syntax_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+
+RSpec.describe(Regexp::Syntax) do
+  specify('unknown name') do
+    expect { Regexp::Syntax.new('ruby/1.0') }.to raise_error(Regexp::Syntax::UnknownSyntaxNameError)
+  end
+
+  specify('new') do
+    expect(Regexp::Syntax.new('ruby/1.9.3')).to be_instance_of(Regexp::Syntax::V1_9_3)
+  end
+
+  specify('new any') do
+    expect(Regexp::Syntax.new('any')).to be_instance_of(Regexp::Syntax::Any)
+    expect(Regexp::Syntax.new('*')).to be_instance_of(Regexp::Syntax::Any)
+  end
+
+  specify('not implemented') do
+    expect { RP.parse('\\p{alpha}', 'ruby/1.8') }.to raise_error(Regexp::Syntax::NotImplementedError)
+  end
+
+  specify('supported?') do
+    expect(Regexp::Syntax.supported?('ruby/1.1.1')).to be false
+    expect(Regexp::Syntax.supported?('ruby/2.4.3')).to be true
+    expect(Regexp::Syntax.supported?('ruby/2.5')).to be true
+  end
+
+  specify('invalid version') do
+    expect { Regexp::Syntax.version_class('2.0.0') }.to raise_error(Regexp::Syntax::InvalidVersionNameError)
+
+    expect { Regexp::Syntax.version_class('ruby/20') }.to raise_error(Regexp::Syntax::InvalidVersionNameError)
+  end
+
+  specify('version class tiny version') do
+    expect(Regexp::Syntax.version_class('ruby/1.9.3')).to eq Regexp::Syntax::V1_9_3
+
+    expect(Regexp::Syntax.version_class('ruby/2.3.1')).to eq Regexp::Syntax::V2_3_1
+  end
+
+  specify('version class minor version') do
+    expect(Regexp::Syntax.version_class('ruby/1.9')).to eq Regexp::Syntax::V1_9
+
+    expect(Regexp::Syntax.version_class('ruby/2.3')).to eq Regexp::Syntax::V2_3
+  end
+end

data/spec/syntax/syntax_token_map_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+RSpec.describe(Regexp::Syntax::Token::Map) do
+  let(:map) { Regexp::Syntax::Token::Map }
+
+  specify('is complete') do
+    latest_syntax = Regexp::Syntax.new('ruby/2.9')
+
+    latest_syntax.features.each do |type, tokens|
+      tokens.each { |token| expect(map[type]).to include(token) }
+    end
+  end
+
+  specify('contains no duplicate type/token combinations') do
+    combinations = map.flat_map do |type, tokens|
+      tokens.map { |token| "#{type} #{token}" }
+    end
+
+    non_uniq = combinations.group_by { |str| str }.select { |_, v| v.count > 1 }
+
+    expect(non_uniq.keys).to be_empty
+  end
+end

data/spec/syntax/versions/1.8.6_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+RSpec.describe(Regexp::Syntax::V1_8_6) do
+  let(:syntax) { Regexp::Syntax.new('ruby/1.8.6') }
+
+  tests = {
+    implements: {
+      assertion: T::Assertion::Lookahead,
+      backref: [:number],
+      escape: T::Escape::Basic + T::Escape::ASCII + T::Escape::Meta + T::Escape::Control,
+      group: T::Group::V1_8_6,
+      quantifier: T::Quantifier::Greedy + T::Quantifier::Reluctant + T::Quantifier::Interval + T::Quantifier::IntervalReluctant
+    },
+    excludes: {
+      assertion: T::Assertion::Lookbehind,
+      backref: T::Backreference::All - [:number] + T::SubexpressionCall::All,
+      quantifier: T::Quantifier::Possessive
+    }
+  }
+
+  tests.each do |method, types|
+    expected = method != :excludes
+
+    types.each do |type, tokens|
+      if tokens.nil? || tokens.empty?
+        specify("syntax_V1_8_#{method}_#{type}") do
+          expect(syntax.implements?(type, nil)).to eq expected
+        end
+      else
+        tokens.each do |token|
+          specify("syntax_V1_8_#{method}_#{type}_#{token}") do
+            expect(syntax.implements?(type, token)).to eq expected
+          end
+        end
+      end
+    end
+  end
+end

data/spec/syntax/versions/1.9.1_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+RSpec.describe(Regexp::Syntax::V1_9_1) do
+  let(:syntax) { Regexp::Syntax.new('ruby/1.9.1') }
+
+  tests = {
+    implements: {
+      escape: T::Escape::Hex + T::Escape::Octal + T::Escape::Unicode,
+      type: T::CharacterType::Hex,
+      quantifier: T::Quantifier::Greedy + T::Quantifier::Reluctant + T::Quantifier::Possessive
+    }
+  }
+
+  tests.each do |method, types|
+    types.each do |type, tokens|
+      tokens.each do |token|
+        specify("syntax_V1_9_1_#{method}_#{type}_#{token}") do
+          expect(syntax.implements?(type, token)).to be true
+        end
+      end
+    end
+  end
+end

data/spec/syntax/versions/1.9.3_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+RSpec.describe(Regexp::Syntax::V1_9_3) do
+  let(:syntax) { Regexp::Syntax.new('ruby/1.9.3') }
+
+  tests = {
+    implements: {
+      property: T::UnicodeProperty::Script_V1_9_3 + T::UnicodeProperty::Age_V1_9_3,
+      nonproperty: T::UnicodeProperty::Script_V1_9_3 + T::UnicodeProperty::Age_V1_9_3
+    }
+  }
+
+  tests.each do |method, types|
+    types.each do |type, tokens|
+      tokens.each do |token|
+        specify("syntax_V1_9_3_#{method}_#{type}_#{token}") do
+          expect(syntax.implements?(type, token)).to be true
+        end
+      end
+    end
+  end
+end