regexp_parser 1.7.1 → 2.2.1

data/spec/scanner/meta_spec.rb

@@ -1,18 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe('Meta scanning') do
-  include_examples 'scan', /abc??|def*+|ghi+/,
-    0  => [:literal,     :literal,                 'abc',  0,  3],
-    1  => [:quantifier,  :zero_or_one_reluctant,   '??',   3,  5],
-    2  => [:meta,        :alternation,             '|',    5,  6],
-    3  => [:literal,     :literal,                 'def',  6,  9],
-    4  => [:quantifier,  :zero_or_more_possessive, '*+',   9,  11],
-    5  => [:meta,        :alternation,             '|',    11, 12]
-
-  include_examples 'scan', /(a\|b)|(c|d)\|(e[|]f)/,
-    2  => [:escape,      :alternation,             '\|',   2,  4],
-    5  => [:meta,        :alternation,             '|',    6,  7],
-    8  => [:meta,        :alternation,             '|',    9,  10],
-    11 => [:escape,      :alternation,             '\|',   12, 14],
-    15 => [:literal,     :literal,                 '|',    17, 18]
-end

data/spec/scanner/properties_spec.rb

@@ -1,64 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe('Property scanning') do
-  RSpec.shared_examples 'scan property' do |text, token|
-    it("scans \\p{#{text}} as property #{token}") do
-      result = RS.scan("\\p{#{text}}")[0]
-      expect(result[0..1]).to eq [:property, token]
-    end
-
-    it("scans \\P{#{text}} as nonproperty #{token}") do
-      result = RS.scan("\\P{#{text}}")[0]
-      expect(result[0..1]).to eq [:nonproperty, token]
-    end
-
-    it("scans \\p{^#{text}} as nonproperty #{token}") do
-      result = RS.scan("\\p{^#{text}}")[0]
-      expect(result[0..1]).to eq [:nonproperty, token]
-    end
-
-    it("scans double-negated \\P{^#{text}} as property #{token}") do
-      result = RS.scan("\\P{^#{text}}")[0]
-      expect(result[0..1]).to eq [:property, token]
-    end
-  end
-
-  include_examples 'scan property', 'Alnum',                :alnum
-
-  include_examples 'scan property', 'XPosixPunct',          :xposixpunct
-
-  include_examples 'scan property', 'Newline',              :newline
-
-  include_examples 'scan property', 'Any',                  :any
-
-  include_examples 'scan property', 'Assigned',             :assigned
-
-  include_examples 'scan property', 'Age=1.1',              :'age=1.1'
-  include_examples 'scan property', 'Age=10.0',             :'age=10.0'
-
-  include_examples 'scan property', 'ahex',                 :ascii_hex_digit
-  include_examples 'scan property', 'ASCII_Hex_Digit',      :ascii_hex_digit # test underscore
-
-  include_examples 'scan property', 'sd',                   :soft_dotted
-  include_examples 'scan property', 'Soft-Dotted',          :soft_dotted # test dash
-
-  include_examples 'scan property', 'Egyp',                 :egyptian_hieroglyphs
-  include_examples 'scan property', 'Egyptian Hieroglyphs', :egyptian_hieroglyphs # test whitespace
-
-  include_examples 'scan property', 'Linb',                 :linear_b
-  include_examples 'scan property', 'Linear-B',             :linear_b # test dash
-
-  include_examples 'scan property', 'InArabic',             :in_arabic # test block
-  include_examples 'scan property', 'in Arabic',            :in_arabic # test block w. whitespace
-  include_examples 'scan property', 'In_Arabic',            :in_arabic # test block w. underscore
-
-  include_examples 'scan property', 'Yiii',                 :yi
-  include_examples 'scan property', 'Yi',                   :yi
-
-  include_examples 'scan property', 'Zinh',                 :inherited
-  include_examples 'scan property', 'Inherited',            :inherited
-  include_examples 'scan property', 'Qaai',                 :inherited
-
-  include_examples 'scan property', 'Zzzz',                 :unknown
-  include_examples 'scan property', 'Unknown',              :unknown
-end

data/spec/scanner/quantifiers_spec.rb

@@ -1,20 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe('Quantifier scanning') do
-  include_examples 'scan', 'a?',     1 => [:quantifier,  :zero_or_one,             '?',     1, 2]
-  include_examples 'scan', 'a??',    1 => [:quantifier,  :zero_or_one_reluctant,   '??',    1, 3]
-  include_examples 'scan', 'a?+',    1 => [:quantifier,  :zero_or_one_possessive,  '?+',    1, 3]
-
-  include_examples 'scan', 'a*',     1 => [:quantifier,  :zero_or_more,            '*',     1, 2]
-  include_examples 'scan', 'a*?',    1 => [:quantifier,  :zero_or_more_reluctant,  '*?',    1, 3]
-  include_examples 'scan', 'a*+',    1 => [:quantifier,  :zero_or_more_possessive, '*+',    1, 3]
-
-  include_examples 'scan', 'a+',     1 => [:quantifier,  :one_or_more,             '+',     1, 2]
-  include_examples 'scan', 'a+?',    1 => [:quantifier,  :one_or_more_reluctant,   '+?',    1, 3]
-  include_examples 'scan', 'a++',    1 => [:quantifier,  :one_or_more_possessive,  '++',    1, 3]
-
-  include_examples 'scan', 'a{2}',   1 => [:quantifier,  :interval,                '{2}',   1, 4]
-  include_examples 'scan', 'a{2,}',  1 => [:quantifier,  :interval,                '{2,}',  1, 5]
-  include_examples 'scan', 'a{,2}',  1 => [:quantifier,  :interval,                '{,2}',  1, 5]
-  include_examples 'scan', 'a{2,4}', 1 => [:quantifier,  :interval,                '{2,4}', 1, 6]
-end

data/spec/scanner/refcalls_spec.rb

@@ -1,36 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe('RefCall scanning') do
-  # Traditional numerical group back-reference
-  include_examples 'scan', '(abc)\1' ,          3 => [:backref, :number,                  '\1',         5, 7]
-
-  # Group back-references, named, numbered, and relative
-  include_examples 'scan', '(?<X>abc)\k<X>',    3 => [:backref, :name_ref_ab,             '\k<X>',      9, 14]
-  include_examples 'scan', "(?<X>abc)\\k'X'",   3 => [:backref, :name_ref_sq,             "\\k'X'",     9, 14]
-
-  include_examples 'scan', '(abc)\k<1>',        3 => [:backref, :number_ref_ab,           '\k<1>',      5, 10]
-  include_examples 'scan', "(abc)\\k'1'",       3 => [:backref, :number_ref_sq,           "\\k'1'",     5, 10]
-
-  include_examples 'scan', '(abc)\k<-1>',       3 => [:backref, :number_rel_ref_ab,       '\k<-1>',     5, 11]
-  include_examples 'scan', "(abc)\\k'-1'",      3 => [:backref, :number_rel_ref_sq,       "\\k'-1'",    5, 11]
-
-  # Sub-expression invocation, named, numbered, and relative
-  include_examples 'scan', '(?<X>abc)\g<X>',    3 => [:backref, :name_call_ab,            '\g<X>',      9, 14]
-  include_examples 'scan', "(?<X>abc)\\g'X'",   3 => [:backref, :name_call_sq,            "\\g'X'",     9, 14]
-
-  include_examples 'scan', '(abc)\g<1>',        3 => [:backref, :number_call_ab,          '\g<1>',      5, 10]
-  include_examples 'scan', "(abc)\\g'1'",       3 => [:backref, :number_call_sq,          "\\g'1'",     5, 10]
-
-  include_examples 'scan', '(abc)\g<-1>',       3 => [:backref, :number_rel_call_ab,      '\g<-1>',     5, 11]
-  include_examples 'scan', "(abc)\\g'-1'",      3 => [:backref, :number_rel_call_sq,      "\\g'-1'",    5, 11]
-
-  include_examples 'scan', '\g<+1>(abc)',       0 => [:backref, :number_rel_call_ab,      '\g<+1>',     0, 6]
-  include_examples 'scan', "\\g'+1'(abc)",      0 => [:backref, :number_rel_call_sq,      "\\g'+1'",    0, 6]
-
-  # Group back-references, with recursion level
-  include_examples 'scan', '(?<X>abc)\k<X-0>',  3 => [:backref, :name_recursion_ref_ab,   '\k<X-0>',    9, 16]
-  include_examples 'scan', "(?<X>abc)\\k'X-0'", 3 => [:backref, :name_recursion_ref_sq,   "\\k'X-0'",   9, 16]
-
-  include_examples 'scan', '(abc)\k<1-0>',      3 => [:backref, :number_recursion_ref_ab, '\k<1-0>',    5, 12]
-  include_examples 'scan', "(abc)\\k'1-0'",     3 => [:backref, :number_recursion_ref_sq, "\\k'1-0'",   5, 12]
-end

data/spec/scanner/sets_spec.rb

@@ -1,102 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe('Set scanning') do
-  include_examples 'scan', /[a]/,                   0 => [:set,    :open,            '[',          0, 1]
-  include_examples 'scan', /[b]/,                   2 => [:set,    :close,           ']',          2, 3]
-  include_examples 'scan', /[^n]/,                  1 => [:set,    :negate,          '^',          1, 2]
-
-  include_examples 'scan', /[c]/,                   1 => [:literal, :literal,        'c',          1, 2]
-  include_examples 'scan', /[\b]/,                  1 => [:escape,  :backspace,      '\b',         1, 3]
-  include_examples 'scan', /[A\bX]/,                2 => [:escape,  :backspace,      '\b',         2, 4]
-
-  include_examples 'scan', /[.]/,                   1 => [:literal, :literal,        '.',          1, 2]
-  include_examples 'scan', /[?]/,                   1 => [:literal, :literal,        '?',          1, 2]
-  include_examples 'scan', /[*]/,                   1 => [:literal, :literal,        '*',          1, 2]
-  include_examples 'scan', /[+]/,                   1 => [:literal, :literal,        '+',          1, 2]
-  include_examples 'scan', /[{]/,                   1 => [:literal, :literal,        '{',          1, 2]
-  include_examples 'scan', /[}]/,                   1 => [:literal, :literal,        '}',          1, 2]
-  include_examples 'scan', /[<]/,                   1 => [:literal, :literal,        '<',          1, 2]
-  include_examples 'scan', /[>]/,                   1 => [:literal, :literal,        '>',          1, 2]
-
-  include_examples 'scan', /[äöü]/,                 2 => [:literal, :literal,        'ö',          3, 5]
-
-  include_examples 'scan', /[\x20]/,                1 => [:escape, :hex,             '\x20',       1, 5]
-
-  include_examples 'scan', '[\.]',                  1 => [:escape, :dot,             '\.',         1, 3]
-  include_examples 'scan', '[\!]',                  1 => [:escape, :literal,         '\!',         1, 3]
-  include_examples 'scan', '[\#]',                  1 => [:escape, :literal,         '\#',         1, 3]
-  include_examples 'scan', '[\\]]',                 1 => [:escape, :set_close,       '\]',         1, 3]
-  include_examples 'scan', '[\\\\]',                1 => [:escape, :backslash,       '\\\\',       1, 3]
-  include_examples 'scan', '[\A]',                  1 => [:escape, :literal,         '\A',         1, 3]
-  include_examples 'scan', '[\z]',                  1 => [:escape, :literal,         '\z',         1, 3]
-  include_examples 'scan', '[\g]',                  1 => [:escape, :literal,         '\g',         1, 3]
-  include_examples 'scan', '[\K]',                  1 => [:escape, :literal,         '\K',         1, 3]
-  include_examples 'scan', '[\R]',                  1 => [:escape, :literal,         '\R',         1, 3]
-  include_examples 'scan', '[\X]',                  1 => [:escape, :literal,         '\X',         1, 3]
-  include_examples 'scan', '[\c2]',                 1 => [:escape, :literal,         '\c',         1, 3]
-  include_examples 'scan', '[\B]',                  1 => [:escape, :literal,         '\B',         1, 3]
-  include_examples 'scan', '[a\-c]',                2 => [:escape, :literal,         '\-',         2, 4]
-
-  include_examples 'scan', /[\d]/,                  1 => [:type,   :digit,           '\d',         1, 3]
-  include_examples 'scan', /[\da-z]/,               1 => [:type,   :digit,           '\d',         1, 3]
-  include_examples 'scan', /[\D]/,                  1 => [:type,   :nondigit,        '\D',         1, 3]
-
-  include_examples 'scan', /[\h]/,                  1 => [:type,   :hex,             '\h',         1, 3]
-  include_examples 'scan', /[\H]/,                  1 => [:type,   :nonhex,          '\H',         1, 3]
-
-  include_examples 'scan', /[\s]/,                  1 => [:type,   :space,           '\s',         1, 3]
-  include_examples 'scan', /[\S]/,                  1 => [:type,   :nonspace,        '\S',         1, 3]
-
-  include_examples 'scan', /[\w]/,                  1 => [:type,   :word,            '\w',         1, 3]
-  include_examples 'scan', /[\W]/,                  1 => [:type,   :nonword,         '\W',         1, 3]
-
-  include_examples 'scan', /[a-b]/,                 1 => [:literal, :literal,        'a',          1, 2]
-  include_examples 'scan', /[a-c]/,                 2 => [:set,     :range,          '-',          2, 3]
-  include_examples 'scan', /[a-d]/,                 3 => [:literal, :literal,        'd',          3, 4]
-  include_examples 'scan', /[a-b-]/,                4 => [:literal, :literal,        '-',          4, 5]
-  include_examples 'scan', /[-a]/,                  1 => [:literal, :literal,        '-',          1, 2]
-  include_examples 'scan', /[a-c^]/,                4 => [:literal, :literal,        '^',          4, 5]
-  include_examples 'scan', /[a-bd-f]/,              2 => [:set,    :range,           '-',          2, 3]
-  include_examples 'scan', /[a-cd-f]/,              5 => [:set,    :range,           '-',          5, 6]
-
-  include_examples 'scan', /[a[:digit:]c]/,         2 => [:posixclass,    :digit,    '[:digit:]',  2, 11]
-  include_examples 'scan', /[[:digit:][:space:]]/,  2 => [:posixclass,    :space,    '[:space:]', 10, 19]
-  include_examples 'scan', /[[:^digit:]]/,          1 => [:nonposixclass, :digit,    '[:^digit:]', 1, 11]
-
-  include_examples 'scan', /[a[.a-b.]c]/,           2 => [:set,    :collation,       '[.a-b.]',    2,  9]
-  include_examples 'scan', /[a[=e=]c]/,             2 => [:set,    :equivalent,      '[=e=]',      2,  7]
-
-  include_examples 'scan', /[a-d&&g-h]/,            4 => [:set,    :intersection,    '&&',         4, 6]
-  include_examples 'scan', /[a&&]/,                 2 => [:set,    :intersection,    '&&',         2, 4]
-  include_examples 'scan', /[&&z]/,                 1 => [:set,    :intersection,    '&&',         1, 3]
-
-  include_examples 'scan', /[a\p{digit}c]/,         2 => [:property,    :digit,      '\p{digit}',  2, 11]
-  include_examples 'scan', /[a\P{digit}c]/,         2 => [:nonproperty, :digit,      '\P{digit}',  2, 11]
-  include_examples 'scan', /[a\p{^digit}c]/,        2 => [:nonproperty, :digit,      '\p{^digit}', 2, 12]
-  include_examples 'scan', /[a\P{^digit}c]/,        2 => [:property,    :digit,      '\P{^digit}', 2, 12]
-
-  include_examples 'scan', /[a\p{ALPHA}c]/,         2 => [:property,    :alpha,      '\p{ALPHA}',  2, 11]
-  include_examples 'scan', /[a\p{P}c]/,             2 => [:property,    :punctuation,'\p{P}',      2, 7]
-  include_examples 'scan', /[a\p{P}\P{P}c]/,        3 => [:nonproperty, :punctuation,'\P{P}',      7, 12]
-
-  include_examples 'scan', /[\x20-\x27]/,
-    1 => [:escape, :hex,             '\x20',       1, 5],
-    2 => [:set,    :range,           '-',          5, 6],
-    3 => [:escape, :hex,             '\x27',       6, 10]
-
-  include_examples 'scan', /[a-w&&[^c-g]z]/,
-    5 => [:set,    :open,            '[',          6, 7],
-    6 => [:set,    :negate,          '^',          7, 8],
-    8 => [:set,    :range,           '-',          9, 10],
-    10=> [:set,    :close,           ']',          11, 12]
-
-  specify('set literal encoding') do
-    text = RS.scan('[a]')[1][2].to_s
-    expect(text).to eq 'a'
-    expect(text.encoding.to_s).to eq 'UTF-8'
-
-    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

@@ -1,14 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe('Type scanning') do
-  include_examples 'scan', 'a\\dc', 1 => [:type, :digit,     '\\d', 1, 3]
-  include_examples 'scan', 'a\\Dc', 1 => [:type, :nondigit,  '\\D', 1, 3]
-  include_examples 'scan', 'a\\hc', 1 => [:type, :hex,       '\\h', 1, 3]
-  include_examples 'scan', 'a\\Hc', 1 => [:type, :nonhex,    '\\H', 1, 3]
-  include_examples 'scan', 'a\\sc', 1 => [:type, :space,     '\\s', 1, 3]
-  include_examples 'scan', 'a\\Sc', 1 => [:type, :nonspace,  '\\S', 1, 3]
-  include_examples 'scan', 'a\\wc', 1 => [:type, :word,      '\\w', 1, 3]
-  include_examples 'scan', 'a\\Wc', 1 => [:type, :nonword,   '\\W', 1, 3]
-  include_examples 'scan', 'a\\Rc', 1 => [:type, :linebreak, '\\R', 1, 3]
-  include_examples 'scan', 'a\\Xc', 1 => [:type, :xgrapheme, '\\X', 1, 3]
-end

data/spec/spec_helper.rb

@@ -1,15 +0,0 @@
-require 'regexp_parser'
-require 'regexp_property_values'
-require_relative 'support/shared_examples'
-
-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/spec/support/runner.rb

@@ -1,42 +0,0 @@
-require 'pathname'
-require 'rspec'
-
-module RegexpParserSpec
-  class Runner
-    def initialize(arguments, warning_whitelist)
-      @arguments = arguments
-      @warning_whitelist = warning_whitelist
-    end
-
-    def run
-      spec_status = nil
-
-      Warning::Filter.new(warning_whitelist).assert_expected_warnings_only do
-        setup
-        spec_status = run_rspec
-      end
-
-      spec_status
-    end
-
-    private
-
-    def setup
-      $VERBOSE = true
-
-      spec_files.each(&method(:require))
-    end
-
-    def run_rspec
-      RSpec::Core::Runner.run([])
-    end
-
-    def spec_files
-      arguments
-        .map { |path| Pathname.new(path).expand_path.freeze }
-        .select(&:file?)
-    end
-
-    attr_reader :arguments, :warning_whitelist
-  end
-end

data/spec/support/shared_examples.rb

@@ -1,77 +0,0 @@
-RSpec.shared_examples 'syntax' do |klass, opts|
-  opts[:implements].each do |type, tokens|
-    tokens.each do |token|
-      it("implements #{token} #{type}") do
-        expect(klass.implements?(type, token)).to be true
-      end
-    end
-  end
-
-  opts[:excludes] && opts[:excludes].each do |type, tokens|
-    tokens.each do |token|
-      it("does not implement #{token} #{type}") do
-        expect(klass.implements?(type, token)).to be false
-      end
-    end
-  end
-end
-
-RSpec.shared_examples 'scan' do |pattern, checks|
-  context "given the pattern #{pattern}" do
-    before(:all) { @tokens = Regexp::Scanner.scan(pattern) }
-
-    checks.each do |index, (type, token, text, ts, te)|
-      it "scans token #{index} as #{token} #{type} at #{ts}..#{te}" do
-        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
-end
-
-RSpec.shared_examples 'lex' do |pattern, checks|
-  context "given the pattern #{pattern}" do
-    before(:all) { @tokens = Regexp::Lexer.lex(pattern) }
-
-    checks.each do |index, (type, token, text, ts, te, lvl, set_lvl, cond_lvl)|
-      it "lexes token #{index} as #{token} #{type} at #{lvl}, #{set_lvl}, #{cond_lvl}" do
-        struct = @tokens.at(index)
-
-        expect(struct.type).to eq type
-        expect(struct.token).to eq token
-        expect(struct.text).to eq text
-        expect(struct.ts).to eq ts
-        expect(struct.te).to eq te
-        expect(struct.level).to eq lvl
-        expect(struct.set_level).to eq set_lvl
-        expect(struct.conditional_level).to eq cond_lvl
-      end
-    end
-  end
-end
-
-RSpec.shared_examples 'parse' do |pattern, checks|
-  context "given the pattern #{pattern}" do
-    before(:all) { @root = Regexp::Parser.parse(pattern, '*') }
-
-    checks.each do |path, (type, token, klass, attributes)|
-      it "parses expression at #{path} as #{klass}" do
-        exp = @root.dig(*path)
-
-        expect(exp).to be_instance_of(klass)
-        expect(exp.type).to eq type
-        expect(exp.token).to eq token
-
-        attributes && attributes.each do |method, value|
-          expect(exp.send(method)).to eq(value),
-            "expected expression at #{path} to have #{method} #{value}"
-        end
-      end
-    end
-  end
-end

data/spec/support/warning_extractor.rb

@@ -1,60 +0,0 @@
-require 'set'
-require 'delegate'
-
-module RegexpParserSpec
-  class Warning
-    class UnexpectedWarnings < StandardError
-      MSG = 'Unexpected warnings: %s'.freeze
-
-      def initialize(warnings)
-        super(MSG % warnings.join("\n"))
-      end
-    end
-
-    class Filter
-      def initialize(whitelist)
-        @whitelist = whitelist
-      end
-
-      def assert_expected_warnings_only
-        original = $stderr
-        $stderr  = Extractor.new(original, @whitelist)
-
-        yield
-
-        assert_no_warnings($stderr.warnings)
-      ensure
-        $stderr = original
-      end
-
-      private
-
-      def assert_no_warnings(warnings)
-        raise UnexpectedWarnings, warnings.to_a if warnings.any?
-      end
-    end
-
-    class Extractor < DelegateClass(IO)
-      PATTERN = /\A(?:.+):(?:\d+): warning: (?:.+)\n\z/
-
-      def initialize(io, whitelist)
-        @whitelist = whitelist
-        @warnings  = Set.new
-        super(io)
-      end
-
-      def write(message)
-        return super if PATTERN !~ message
-
-        warning = message.chomp
-        @warnings << warning if @whitelist.none?(&warning.method(:include?))
-
-        self
-      end
-
-      def warnings
-        @warnings.dup.freeze
-      end
-    end
-  end
-end

data/spec/syntax/syntax_spec.rb

@@ -1,48 +0,0 @@
-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
-
-  specify('raises for unknown constant lookups') do
-    expect { Regexp::Syntax::V1 }.to raise_error(/V1/)
-  end
-end

data/spec/syntax/syntax_token_map_spec.rb

@@ -1,23 +0,0 @@
-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

@@ -1,17 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe(Regexp::Syntax::V1_8_6) do
-  include_examples 'syntax', Regexp::Syntax.new('ruby/1.8.6'),
-  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
-  }
-end

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

@@ -1,10 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe(Regexp::Syntax::V1_9_1) do
-  include_examples 'syntax', Regexp::Syntax.new('ruby/1.9.1'),
-  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
-  }
-end

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

@@ -1,9 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe(Regexp::Syntax::V1_9_3) do
-  include_examples 'syntax', Regexp::Syntax.new('ruby/1.9.3'),
-  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
-  }
-end

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

@@ -1,13 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe(Regexp::Syntax::V2_0_0) do
-  include_examples 'syntax', Regexp::Syntax.new('ruby/2.0.0'),
-  implements: {
-    property: T::UnicodeProperty::Age_V2_0_0,
-    nonproperty: T::UnicodeProperty::Age_V2_0_0
-  },
-  excludes: {
-    property: [:newline],
-    nonproperty: [:newline]
-  }
-end

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

@@ -1,9 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe(Regexp::Syntax::V2_2_0) do
-  include_examples 'syntax', Regexp::Syntax.new('ruby/2.2.0'),
-  implements: {
-    property: T::UnicodeProperty::Script_V2_2_0 + T::UnicodeProperty::Age_V2_2_0,
-    nonproperty: T::UnicodeProperty::Script_V2_2_0 + T::UnicodeProperty::Age_V2_2_0
-  }
-end

data/spec/syntax/versions/aliases_spec.rb

@@ -1,37 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe(Regexp::Syntax) do
-  RSpec.shared_examples 'syntax alias' do |string, klass|
-    it "aliases #{string} to #{klass}" do
-      syntax = Regexp::Syntax.new(string)
-      expect(syntax).to be_a klass
-    end
-  end
-
-  include_examples 'syntax alias', 'ruby/1.8.6',  Regexp::Syntax::V1_8_6
-  include_examples 'syntax alias', 'ruby/1.8',    Regexp::Syntax::V1_8_6
-  include_examples 'syntax alias', 'ruby/1.9.1',  Regexp::Syntax::V1_9_1
-  include_examples 'syntax alias', 'ruby/1.9',    Regexp::Syntax::V1_9_3
-  include_examples 'syntax alias', 'ruby/2.0.0',  Regexp::Syntax::V1_9
-  include_examples 'syntax alias', 'ruby/2.0',    Regexp::Syntax::V2_0_0
-  include_examples 'syntax alias', 'ruby/2.1',    Regexp::Syntax::V2_0_0
-  include_examples 'syntax alias', 'ruby/2.2.0',  Regexp::Syntax::V2_0_0
-  include_examples 'syntax alias', 'ruby/2.2.10', Regexp::Syntax::V2_0_0
-  include_examples 'syntax alias', 'ruby/2.2',    Regexp::Syntax::V2_0_0
-  include_examples 'syntax alias', 'ruby/2.3.0',  Regexp::Syntax::V2_3_0
-  include_examples 'syntax alias', 'ruby/2.3',    Regexp::Syntax::V2_3_0
-  include_examples 'syntax alias', 'ruby/2.4.0',  Regexp::Syntax::V2_4_0
-  include_examples 'syntax alias', 'ruby/2.4.1',  Regexp::Syntax::V2_4_1
-  include_examples 'syntax alias', 'ruby/2.5.0',  Regexp::Syntax::V2_4_1
-  include_examples 'syntax alias', 'ruby/2.5',    Regexp::Syntax::V2_5_0
-  include_examples 'syntax alias', 'ruby/2.6.0',  Regexp::Syntax::V2_5_0
-  include_examples 'syntax alias', 'ruby/2.6.2',  Regexp::Syntax::V2_6_2
-  include_examples 'syntax alias', 'ruby/2.6.3',  Regexp::Syntax::V2_6_3
-  include_examples 'syntax alias', 'ruby/2.6',    Regexp::Syntax::V2_6_3
-
-  specify('future alias warning') do
-    expect { Regexp::Syntax.new('ruby/5.0') }
-      .to output(/This library .* but you are running .* \(feature set of .*\)/)
-      .to_stderr
-  end
-end