All Java classes bound into Ruby should provide an allocator/initialize combo or documentation why they do not

Finish for 0.9.9. Most of this has already been done.

None of these have been reported as issues (except one or two folks mentioning that Thread actually tries to marshal), so I'm bumping it to 1.0. We need to tidy these up, but they don't appear to be affecting anyone.

Punting to post-1.0, barring any reported problems that make it critical. If there's anything to do, we'll do it. Otherwise, it's not hurting anyone.

Most cases were fixed; others have never been reported or will be different in the future (like new Java Integration stuff).

For anyone that runs into additional cases, you can use _load and _dump to get around allocator issues:

class NativeException
  def _dump(*)
    'whatever'
  end

  def self._load(str)
    nil
  end
end

begin
  java.lang.System.getProperty(nil)
rescue NativeException => e
  p Marshal.load(Marshal.dump(e))
end

The contract of _dump is that it returns a String containing everything you need to _load later on. _dump receives as an argument the "depth limit" for dumping, i.e. the most levels the caller intends for the object graph to reach. The contract of _load is that it receives that String and you use it to reconstitute your object in whatever way is appropriate.

This example dumps nonsense and has load simply return nil, so NativeExceptions in the marshal stream will come back as nil; but it could also marshal an exception name or the contained Java exception itself. Choose your own adventure.

With DRb, I wanted exceptions generated on the server to be caught on the client, so this works well:

class NativeException
def _dump
Marshal.dump( [cause, backtrace] )
end
def self._load(str)
exception, trace = Marshal.load(str)
meta = class << exception; self; end
meta.send(:define_method, :backtrace) { trace }
exception
end
end