Serializable

This npm provides a Serializable mixin to streamline the process of writing
serializable classes. Include the mixin and implement two instance methods
(::serializeParams and ::deserializeParams) to add serialization to your
class.

Before digging into how to implement serializable classes, let's touch on how
to use them. To serialize an object, call ::serialize. To deserialize an
object, call .deserialize on its class with the results of a previous call to
::serialize.

You can pass .deserialize an optional second argument containing additional
non-serializable parameters which will be merged with the deserialized
parameters when constructing the object. For example, say that trains need a
reference to a RailNetwork instance, but that the RailNetwork isn't
serialized as part of Train:

train1 =newTrain(cars:20, hasCaboose:true, railNetwork: network)

train1State = train1.serialize()# does not contain a serialized RailNetwork

This method should return a plain JavaScript object containing the serialized
version of all parameters required to reconstruct the object.

classAutomobileextendsVehicle

Serializable.includeInto(this)

constructor:(@doors=4, @engine='v8')->

serializeParams:->{@doors, @engine}

If all your parameters are scalars, this is all that's required. When
deserializing, Serializable will match up the names of the keys in the params hash
with the names of your constructor parameters to reconstruct your object.

auto1 =newAutomobile(2, 'v6')

auto2 = Automobile.deserialize(auto1.serialize())

expect(auto2.doors).toBe 2

expect(auto2.engine).toBe 'v6'

You can also take a params hash as your constructor argument, in which case
Serializable won't attempt to match up constructor parameter names.

If your params hash contains nested serialized objects, you'll need to
deserialize the nested objects before they are passed to the constructor of the
parent object. You perform this deserialization in the optional
::deserializeParams instance method.

classPlaneextendsVehicle

constructor:(@engines, @pilot)->

@pilot?=newPilot(name:"Bob", plane:this)

serializeParams:->{@engines, pilot:@pilot.serialize()}

deserializeParams:(params)->

params.pilot = Pilot.deserialize(params.pilot, plane:this)

params

Using some JS trickery, this method is called before your object's
constructor, allowing you to reference the instance being deserialized when
deserializing its children. You can also perform pre-initialization in this
method. Note that it is safe to modify the params object that is passed
into your method. This is convenient when only a subset of your params need to
be deserialized.

If you can't know the specific class of the object you are deserializing ahead
of time, you can call ::registerDeserializers on a superclass (or any
serializable class) to enable polymorphic deserialization.