Serialize arbitrary object within an Array key

store and retrieve instances of Thing:
class Example
  include MongoMapper::Document
  key :things, Array, :serialize => Thing
end

example.things << Thing.new

lib/mongomapper/embedded_document.rb

@@ -259,6 +259,8 @@ def mongodb_attributes
               if key.native?
                 if key.type == Date and date = instance_variable_get("@#{key.name}")
                   key.normalize_date(date)
+                elsif key.type == Array && key.options[:serialize]
+                  key.serialize(read_attribute(key.name))
                 else
                   read_attribute(key.name)
                 end

lib/mongomapper/key.rb

@@ -47,17 +47,30 @@ def normalize_date(value)
     rescue
       nil
     end
-
+
+    def deserialize_array(value)
+      values = Array(value)
+      if klass = options[:serialize]
+        values.map {|attrs| klass.new attrs}
+      else
+        values
+      end
+    end
+
+    def serialize(values)
+      values.map {|o| o.attributes}
+    end
+
     private
       def typecast(value)
         return value if type.nil?
         return HashWithIndifferentAccess.new(value) if value.is_a?(Hash) && type == Hash
         return value.utc if type == Time && value.kind_of?(type)
-        return value if value.kind_of?(type) || value.nil?
+        return value if (value.kind_of?(type) || value.nil?) && type != Array
         begin
           if    type == String    then value.to_s
           elsif type == Float     then value.to_f
-          elsif type == Array     then value.to_a
+          elsif type == Array     then deserialize_array(value)
           elsif type == Time      then Time.parse(value.to_s).utc
           elsif type == Date      then normalize_date(value)
           elsif type == Boolean   then Boolean.mm_typecast(value)
@@ -83,4 +96,4 @@ def typecast_embedded_document(value)
         value.is_a?(type) ? value : type.new(value)
       end
   end
-end
+end

test/functional/test_document.rb

@@ -94,6 +94,33 @@ def setup
         doc.tags.should == %w(foo bar)
         @document.find(doc.id).tags.should == %w(foo bar)
       end
+
+      should "serializes and deserializes the attributes" do
+        Thing = Class.new do
+          def initialize(hash={})
+            hash.each{|k,v| instance_variable_set("@#{k}", v)}
+          end
+
+          def attributes
+            instance_values
+          end
+
+          def ==(other)
+            attributes == other.attributes
+          end
+        end
+        @document.key :things, Array, :serialize => Thing
+
+        thing = Thing.new :name => 'foo'
+        doc = @document.new
+        doc.things << thing
+        doc.save
+        from_db = @document.find(doc.id)
+        from_db.things.should == [thing]
+        from_db.save
+        doc = @document.find(from_db.id)
+        doc.things.should == from_db.things
+      end
     end
 
     context "Using key with type Hash" do