Marshal logic to preserve object accross a request

object.go

@@ -27,7 +27,7 @@ func NewObject(id string, objType string, attributes interface{}) (*Object, Send
 		Relationships: map[string]*Object{},
 	}
 
-	rawJSON, err := json.MarshalIndent(attributes, "", "  ")
+	rawJSON, err := json.MarshalIndent(attributes, "", " ")
 	if err != nil {
 		return nil, ISE(fmt.Sprintf("Error marshaling attrs while creating a new JSON Object: %s", err))
 	}
@@ -58,31 +58,41 @@ func NewObject(id string, objType string, attributes interface{}) (*Object, Send
 //		// log errors via error.ISE
 //		jsh.Send(w, r, errors)
 //	}
-func (o *Object) Unmarshal(objType string, target interface{}) (err SendableError) {
+func (o *Object) Unmarshal(objType string, target interface{}) SendableError {
 
 	if objType != o.Type {
-		err = ISE(fmt.Sprintf(
+		return ISE(fmt.Sprintf(
 			"Expected type %s, when converting actual type: %s",
 			objType,
 			o.Type,
 		))
-		return
 	}
 
 	jsonErr := json.Unmarshal(o.Attributes, target)
 	if jsonErr != nil {
-		err = ISE(fmt.Sprintf(
+		return ISE(fmt.Sprintf(
 			"For type '%s' unable to marshal: %s\nError:%s",
 			objType,
 			string(o.Attributes),
 			jsonErr.Error(),
 		))
-		return
 	}
 
 	return validateInput(target)
 }
 
+// Marshal allows you to load a modified payload back into an object to preserve
+// all of the data it has
+func (o *Object) Marshal(attributes interface{}) SendableError {
+	raw, err := json.MarshalIndent(attributes, "", " ")
+	if err != nil {
+		return ISE(fmt.Sprintf("Error marshaling attrs while creating a new JSON Object: %s", err))
+	}
+
+	o.Attributes = raw
+	return nil
+}
+
 // Prepare creates a new JSON single object response with an appropriate HTTP status
 // to match the request method type.
 func (o *Object) Prepare(r *http.Request, response bool) (*Response, SendableError) {

object_test.go

@@ -106,6 +106,19 @@ func TestObject(t *testing.T) {
 			})
 		})
 
+		Convey("->Marshal()", func() {
+
+			Convey("should properly update attributes", func() {
+				attrs := map[string]string{"foo": "baz"}
+				err := testObject.Marshal(attrs)
+				So(err, ShouldBeNil)
+
+				raw, jsonErr := json.MarshalIndent(attrs, "", " ")
+				So(jsonErr, ShouldBeNil)
+				So(string(testObject.Attributes), ShouldEqual, string(raw))
+			})
+		})
+
 		Convey("->Prepare()", func() {
 
 			Convey("should handle a POST response correctly", func() {

parser.go

@@ -37,14 +37,14 @@ const (
 //		yourType.ID = obj.ID
 //		// do business logic
 //
-//		response, err := jsh.NewObject(yourType.ID, "yourtype", &yourType)
+//		err := object.Marshal(yourType)
 //		if err != nil {
 //			// log error
 //			err := jsh.Send(w, r, err)
 //			return
 //		}
 //
-//		err := jsh.Send(w, r, response)
+//		err := jsh.Send(w, r, object)
 //	}
 func ParseObject(r *http.Request) (*Object, SendableError) {