Revert "Remove experimental serialization support which I don't think was ever used"

This reverts commit ed8ef16.  We do
in fact have a single test which makes sure via JI we can serialize
a RubyObject.  Whether this really works?  Putting back for now.

Author: enebo

core/src/main/java/org/jruby/BasicObjectStub.java

@@ -199,7 +199,7 @@ public static RubyString convertToString(IRubyObject self) {
 
     public static IRubyObject anyToString(IRubyObject self) {
         final RubyClass metaClass = getMetaClass(self);
-        String cname = metaClass.getRealClass().getName(metaClass.runtime.getCurrentContext());
+        String cname = metaClass.getRealClass().getName();
         /* 6:tags 16:addr 1:eos */
         return metaClass.runtime.newString("#<" + cname + ":0x" + Integer.toHexString(System.identityHashCode(self)) + '>');
     }

core/src/main/java/org/jruby/RubyBasicObject.java

@@ -2902,6 +2902,61 @@ protected String validateInstanceVariable(IRubyObject name) {
         }).idString();
     }
 
+    /**
+     * Serialization of a Ruby (basic) object involves three steps:
+     *
+     * <ol>
+     * <li>Dump the object itself</li>
+     * <li>Dump a String used to load the appropriate Ruby class</li>
+     * <li>Dump each variable from varTable in turn</li>
+     * </ol>
+     *
+     * The metaClass field is marked transient since Ruby classes generally will
+     * not be able to serialize (since they hold references to method tables,
+     * other classes, and potentially thread-, runtime-, or jvm-local state.
+     *
+     * The varTable field is transient because the layout of the same class may
+     * differ across runtimes, since it is determined at runtime based on the
+     * order in which variables get assigned for a given class. We serialize
+     * entries by name to allow other layouts to work properly.
+     */
+    private void writeObject(ObjectOutputStream oos) throws IOException {
+        if (metaClass.isSingleton()) {
+            throw new IOException("can not serialize singleton object");
+        }
+
+        oos.defaultWriteObject();
+        oos.writeUTF(metaClass.getName());
+
+        metaClass.getVariableTableManager().serializeVariables(this, oos);
+    }
+
+    /**
+     * Deserialization proceeds as follows:
+     *
+     * <ol>
+     * <li>Deserialize the object instance. It will have null metaClass and
+     * varTable fields.</li>
+     * <li>Deserialize the name of the object's class, and retrieve class from a
+     * thread-local JRuby instance.</li>
+     * <li>Retrieve each variable in turn, re-assigning them by name.</li>
+     * </ol>
+     *
+     * @see RubyBasicObject#writeObject(java.io.ObjectOutputStream)
+     */
+    private void readObject(ObjectInputStream ois) throws IOException, ClassNotFoundException {
+        Ruby ruby = Ruby.getThreadLocalRuntime();
+
+        if (ruby == null) {
+            throw new IOException("No thread-local org.jruby.Ruby available; can't deserialize Ruby object. Set with Ruby#setThreadLocalRuntime.");
+        }
+
+        ois.defaultReadObject();
+        metaClass = (RubyClass)ruby.getClassFromPath(ois.readUTF());
+
+        metaClass.getVariableTableManager().deserializeVariables(this, ois);
+    }
+
     /**
      * Retrieve the call sites for this class.
      *

core/src/main/java/org/jruby/RubyObject.java

@@ -519,6 +519,68 @@ private static boolean isArrayDig(IRubyObject obj, ObjectSites sites) {
         return obj instanceof RubyArray && sites.dig_array.isBuiltin(obj.getMetaClass());
     }
 
+    /**
+     * Tries to support Java serialization of Ruby objects. This is
+     * still experimental and might not work.
+     */
+    // NOTE: Serialization is primarily supported for testing purposes, and there is no general
+    // guarantee that serialization will work correctly. Specifically, instance variables pointing
+    // at symbols, threads, modules, classes, and other unserializable types are not detected.
+    private void writeObject(ObjectOutputStream out) throws IOException {
+        out.defaultWriteObject();
+
+        // write out ivar count followed by name/value pairs
+        ObjectOutputter outputter = new ObjectOutputter(out);
+        forEachInstanceVariable(outputter);
+        outputter.writeCount();
+        forEachInstanceVariable(outputter);
+    }
+
+    private static class ObjectOutputter implements BiConsumer<String, IRubyObject> {
+        final ObjectOutputStream out;
+        int count = 0;
+        boolean counting = true;
+
+        ObjectOutputter(ObjectOutputStream out) {
+            this.out = out;
+        }
+
+        public void accept(String name, IRubyObject value) {
+            if (counting) {
+                count++;
+            } else {
+                try {
+                    out.writeObject(name);
+                    out.writeObject(value);
+                } catch (IOException ioe) {
+                    throwException(ioe);
+                }
+            }
+        }
+
+        public void writeCount() {
+            try {
+                out.writeInt(count);
+                counting = false;
+            } catch (IOException ioe) {
+                throwException(ioe);
+            }
+        }
+    }
+
+    /**
+     * Tries to support Java unserialization of Ruby objects. This is
+     * still experimental and might not work.
+     */
+    private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
+        in.defaultReadObject();
+        // rest in ivar count followed by name/value pairs
+        int ivarCount = in.readInt();
+        for (int i = 0; i < ivarCount; i++) {
+            setInstanceVariable((String)in.readObject(), (IRubyObject)in.readObject());
+        }
+    }
+
     private static ObjectSites sites(ThreadContext context) {
         return context.sites.Object;
     }

core/src/main/java/org/jruby/runtime/ivars/VariableTableManager.java

@@ -482,6 +482,28 @@ public boolean hasInstanceVariables(RubyBasicObject object) {
         return false;
     }
 
+    public void serializeVariables(RubyBasicObject object, ObjectOutputStream oos) throws IOException {
+        if (object.varTable != null) {
+            Map<String, VariableAccessor> accessors = getVariableAccessorsForRead();
+            oos.writeInt(accessors.size());
+            for (VariableAccessor accessor : accessors.values()) {
+                oos.writeUTF(RubyBasicObject.ERR_INSECURE_SET_INST_VAR);
+                oos.writeObject(accessor.get(object));
+            }
+        } else {
+            oos.writeInt(0);
+        }
+    }
+
+    public void deserializeVariables(RubyBasicObject object, ObjectInputStream ois) throws IOException, ClassNotFoundException {
+        int varCount = ois.readInt();
+        for (int i = 0; i < varCount; i++) {
+            String name = ois.readUTF();
+            Object value = ois.readObject();
+            getVariableAccessorForWrite(name).set(object, value);
+        }
+    }
+
     public Object clearVariable(RubyBasicObject object, String name) {
         synchronized(object) {
             Object value = getVariableAccessorForRead(name).get(object);