🚧 Check if the Data implementation is sufficient

This should _not_ be merged into main.  😉

It's only temporary, until bugs in TruffleRuby and JRuby are addressed:
* jruby/jruby#8829
* truffleruby/truffleruby#3846
* truffleruby/truffleruby#3847

The JRuby bug is a showstopper.  The TruffleRuby bugs are cosmetic
(inspect "nil" vs "") or academic (we never create recursive Data).

Author: nevans

lib/net/imap/data_lite.rb

@@ -26,12 +26,54 @@
 
 module Net
   class IMAP
-    data_or_object =
-      if RUBY_VERSION >= "3.2.0" && defined?(::Data) && ::Data.respond_to?(:define)
-        ::Data
-      else
-        Object
+
+    # :nocov:
+    # Skip coverage: how much of the file runs depends on the engine version.
+
+    # Test whether RUBY_ENGINE has sufficient support for ::Data.
+    # TODO: golf this down to the bare minimum that's failing.
+    data_or_object = ::Object
+    if defined?(::Data) && ::Data.respond_to?(:define)
+      begin
+        class TestData < ::Data
+          def self.YAML(data)
+            coder = Struct.new(:map).new(data)
+            data = self.allocate
+            data.init_with(coder)
+            data
+          end
+          def init_with(coder) initialize(**coder.map.transform_keys(&:to_sym)) end
+          def deconstruct; [:ok, *super] end
+        end
+
+        class TestDataDefine < TestData.define(:str, :bool)
+          def initialize(str: nil, bool: nil)
+            str  => String       | nil; str  = -str if str
+            bool => true | false | nil; bool = !!bool
+            super
+          end
+        end
+
+        test_init = TestDataDefine.YAML({"str" => "str"})
+        test_empty = TestData.define[]
+
+        if test_init.deconstruct != [:ok, "str", false]
+          raise "subclassing misbehaves"
+        elsif test_empty.deconstruct != [:ok]
+          raise "can't define empty"
+        end
+        data_or_object = ::Data
+      rescue => ex
+        warn "Insufficient implementation of Data: %s (%s) for %s %s" % [
+          ex, ex.class, RUBY_ENGINE, RUBY_ENGINE_VERSION,
+        ]
+        data_or_object = ::Object
+      ensure
+        remove_const :TestData       if const_defined?(:TestData)
+        remove_const :TestDataDefine if const_defined?(:TestDataDefine)
       end
+    end
+
     class DataLite < data_or_object
       def encode_with(coder) coder.map = to_h.transform_keys(&:to_s)        end
       def init_with(coder) initialize(**coder.map.transform_keys(&:to_sym)) end
@@ -41,9 +83,7 @@ def init_with(coder) initialize(**coder.map.transform_keys(&:to_sym)) end
   end
 end
 
-# :nocov:
-# Need to skip test coverage for the rest, because it isn't loaded by ruby 3.2+.
-return if RUBY_VERSION >= "3.2.0" && defined?(::Data) && ::Data.respond_to?(:define)
+return unless Net::IMAP::DataLite.superclass == Object
 
 module Net
   class IMAP

test/net/imap/test_data_lite.rb

@@ -154,6 +154,7 @@ def test_inspect
       end
 
       def test_recursive_inspect
+        # TODO: TruffleRuby's Data fails this test with a StackOverflowError
         klass = Data.define(:value, :head, :tail) do
           def initialize(value:, head: nil, tail: nil)
             case tail
@@ -183,6 +184,7 @@ def initialize(value:, head: nil, tail: nil)
           " tail=#<data value=3, head=#{seen}," \
           " tail=#<data value=4, head=#{seen}," \
           " tail=nil>>>>",
+          # TODO: JRuby's Data fails on the next line
           list.inspect
         )
 
@@ -196,6 +198,7 @@ def initialize(value:, head: nil, tail: nil)
           " tail=#<data DoubleLinkList value=3, head=#{seen}," \
           " tail=#<data DoubleLinkList value=4, head=#{seen}," \
           " tail=nil>>>>",
+          # TODO: JRuby's Data fails on the next line
           list.inspect
         )
       ensure
@@ -340,6 +343,47 @@ def other
         assert_equal("test", data.name)
         assert_equal("other", data.other)
       end
+
+      class Abstract < Data
+      end
+
+      class Inherited < Abstract.define(:foo)
+      end
+
+      def test_subclass_can_create
+        # TODO: JRuby's Data fails all of these
+        assert_equal 1, Inherited[1]    .foo
+        assert_equal 2, Inherited[foo: 2].foo
+        assert_equal 3, Inherited.new(3).foo
+        assert_equal 4, Inherited.new(foo: 4).foo
+      end
+
+      class AbstractWithClassMethod < Data
+        def self.inherited_class_method; :ok end
+      end
+
+      class InheritsClassMethod < AbstractWithClassMethod.define(:foo)
+      end
+
+      def test_subclass_class_method
+        # TODO: JRuby's Data fails on the next line
+        assert_equal :ok, InheritsClassMethod.inherited_class_method
+      end
+
+      class AbstractWithOverride < Data
+        def deconstruct; [:ok, *super] end
+      end
+
+      class InheritsOverride < AbstractWithOverride.define(:foo)
+      end
+
+      def test_subclass_override_deconstruct
+        # TODO: JRuby's Data fails on the next line
+        data = InheritsOverride[:foo]
+        # TODO: TruffleRuby's Data fails on the next line
+        assert_equal %i[ok foo], data.deconstruct
+      end
+
     end
   end
 end

test/net/imap/test_imap_connection_state.rb

@@ -26,13 +26,15 @@ class ConnectionStateTest < Test::Unit::TestCase
   end
 
   test "#deconstruct" do
+    # TODO: TruffleRuby's Data fails these
     assert_equal [:not_authenticated], NotAuthenticated[].deconstruct
     assert_equal [:authenticated],     Authenticated[]   .deconstruct
     assert_equal [:selected],          Selected[]        .deconstruct
     assert_equal [:logout],            Logout[]          .deconstruct
   end
 
   test "#deconstruct_keys" do
+    # TODO: TruffleRuby's Data fails these
     assert_equal({symbol: :not_authenticated}, NotAuthenticated[].deconstruct_keys([:symbol]))
     assert_equal({symbol: :authenticated},     Authenticated[]   .deconstruct_keys([:symbol]))
     assert_equal({symbol: :selected},          Selected[]        .deconstruct_keys([:symbol]))