🧪 Add (failing) test for Regexp#linear_time?

Author: nevans

test/net/imap/regexp_collector.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+class RegexpCollector
+  ConstantRegexp = Data.define(:mod, :const_name, :regexp) do
+    def name = "%s::%s" % [mod, const_name]
+  end
+
+  InstanceMethodRegexp = Data.define(:mod, :method_name, :regexp) do
+    def name = "%s#%s: %p" % [mod, method_name, regexp]
+  end
+
+  SingletonMethodRegexp = Data.define(:mod, :method_name, :regexp) do
+    def name = "%s.%s: %p" % [mod, method_name, regexp]
+  end
+
+  attr_reader :mod, :exclude, :exclude_map
+
+  def initialize(mod, exclude: [], exclude_map: {})
+    @mod = mod
+    @exclude = exclude
+    @exclude_map = exclude_map
+  end
+
+  def to_a = (consts + code).flat_map { collect_regexps _1 }
+  def to_h = to_a.group_by(&:name).transform_values(&:first)
+
+  def excluded?(name_or_obj) =
+    exclude&.include?(name_or_obj) || exclude_map[mod]&.include?(name_or_obj)
+
+  def consts
+    @consts = mod
+      .constants(false)
+      .reject { excluded? _1 }
+      .map    { [_1, mod.const_get(_1)] }
+      .select { _2 in Regexp | Module }
+      .reject { excluded? _2 }
+      .reject { _2 in Module and "%s::%s" % [mod, _1] != _2.name }
+  end
+
+  def code
+    return [] unless defined?(RubyVM::InstructionSequence)
+    [
+      *(mod.methods(false) + mod.private_methods(false))
+        .map { mod.method _1 },
+      *(mod.instance_methods(false) + mod.private_instance_methods(false))
+        .map { mod.instance_method _1 },
+    ]
+      .reject { excluded?(_1) || excluded?(_2) }
+  end
+
+  protected attr_writer :mod
+
+  private
+
+  def collect_regexps(obj) = case obj
+  in name, Module  => submod then dup.tap do _1.mod = submod end.to_a
+  in name, Regexp  => regexp then ConstantRegexp.new mod, name, regexp
+  in Method        => method then method_regexps SingletonMethodRegexp, method
+  in UnboundMethod => method then method_regexps InstanceMethodRegexp,  method
+  end
+
+  def method_regexps(klass, method)
+    iseq_regexps(RubyVM::InstructionSequence.of(method))
+      .map { klass.new mod, method.name, _1 }
+  end
+
+  def iseq_regexps(obj) = case obj
+  in RubyVM::InstructionSequence then iseq_regexps obj.to_a
+  in Array                       then obj.flat_map { iseq_regexps _1 }.uniq
+  in Regexp                      then excluded?(obj) ? [] : obj
+  else []
+  end
+
+end

test/net/imap/test_regexps.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require "net/imap"
+require "test/unit"
+
+return unless Regexp.respond_to?(:linear_time?)
+
+begin
+  require_relative "regexp_collector"
+rescue LoadError
+  warn "Can't collect regexps to test Regexp.linear_time?(...)"
+end
+
+unless defined?(RegexpCollector)
+  class RegexpCollector # :nodoc:
+    def initialize(...) end
+    def to_a; [] end
+    def to_h; {} end
+  end
+end
+
+class IMAPRegexpsTest < Test::Unit::TestCase
+
+  data(
+    RegexpCollector.new(
+      Net::IMAP,
+      exclude_map: {
+        Net::IMAP => %i[BodyTypeAttachment BodyTypeExtension], # deprecated
+      },
+      exclude: [
+        /\n(?!\z)/n, # TODO (in Net::IMAP#put_string)
+        Net::IMAP::StringPrep::Tables::BIDI_FAILS_REQ2, # TODO
+        Net::IMAP::StringPrep::Tables::BIDI_FAILS_REQ3, # TODO
+        # The following regexps are built using BIDI_FAILS_REQ{2,3}
+        Net::IMAP::StringPrep::Tables::BIDI_FAILURE,
+        Net::IMAP::StringPrep::SASLprep::PROHIBITED,
+        Net::IMAP::StringPrep::SASLprep::PROHIBITED_STORED,
+      ]
+    ).to_h
+  )
+
+  def test_linear_time(data)
+    assert Regexp.linear_time?(data.regexp)
+  end
+
+end