Initial spike on dot notation

Adds simple implementation of dot notation extraction for nested data
structures in mongo data objects.

Allows for flattening of:
```
{"name": {"first": "Jane", "last": "Doe"}}
```

By using "name.first" as the accessor for "Jane". This is accomplished
by using gjson's accessors of JSON strings.

Author: zph

glide.lock

@@ -36,3 +36,4 @@ import:
 - package: github.com/heroku/rollrus
 - package: github.com/pkg/errors
 - package: github.com/stvp/roll
+- package: github.com/tidwall/gjson

glide.yaml

@@ -9,10 +9,10 @@ import (
 	"time"
 
 	log "github.com/Sirupsen/logrus"
+	"github.com/tidwall/gjson"
 
 	rollus "github.com/heroku/rollrus"
 	"github.com/rwynn/gtm"
-	"gopkg.in/mgo.v2/bson"
 )
 
 func FetchEnvsAndFlags() (e Env) {
@@ -116,47 +116,34 @@ func isActionableOperation(filters ...func() bool) bool {
 }
 
 // SanitizeData handles type inconsistency between mongo and pg
+// and flattens the data from a potentially nested data struct
+// into a flattened struct using gjson.
 func SanitizeData(pgFields Fields, op *gtm.Op) map[string]interface{} {
 	if !IsInsertUpdateDelete(op) {
 		return make(map[string]interface{})
 	}
 
-	newData := op.Data
+	newData, err := json.Marshal(op.Data)
+	parsed := gjson.ParseBytes(newData)
+	output := make(map[string]interface{})
+	if err != nil {
+		log.Errorf("Failed to marshal op.Data into json %s", err.Error())
+	}
 	// Normalize data map to always include the Id with conversion
 	if op.Id != nil {
-		newData["_id"] = op.Id
+		output["_id"] = op.Id
 	}
+
 	for k, v := range pgFields {
-		// Guard against nil values sneaking into dataset
-		if v.Mongo.Type == "id" && newData[k] != nil {
-			newData[k] = newData[k].(bson.ObjectId).Hex()
-		} else if sym, ok := newData[k].(bson.ObjectId); ok {
-			newData[k] = sym.Hex()
-		} else if sym, ok := newData[k].(bson.Symbol); ok {
-			// Handle bson.Symbols which are unknown types for SQL driver
-			newData[k] = string(sym)
-		} else if sym, ok := newData[k].(map[string]interface{}); ok {
-			// Convert hashes to json strings
-			js, err := json.Marshal(sym)
-			if err == nil {
-				newData[k] = js
-			}
-		} else if sym, ok := newData[k].([]interface{}); ok {
-			// Convert array objects to json strings
-			js, err := json.Marshal(sym)
-			if err == nil {
-				newData[k] = js
-			}
-		} else if v.Mongo.Type == "object" {
-			// Convert objects to json strings
-			// TODO: deprecate this since we type check elsewhere
-			js, err := json.Marshal(newData[k])
-			if err == nil {
-				newData[k] = js
-			}
+		// Dot notation extraction
+		maybe := parsed.Get(k)
+		if !maybe.Exists() {
+			continue
 		}
+
+		output[v.Postgres.Name] = maybe.Value()
 	}
-	return newData
+	return output
 }
 
 func createFanKey(db string, collection string) string {

utils.go

@@ -27,6 +27,29 @@ func (s *MySuite) TestSanitizeData(c *C) {
 		actual := m.SanitizeData(BuildFields("_id", "name", "age", "location_id"), t.op)
 		c.Check(actual, DeepEquals, t.result)
 	}
+
+	// Test nested data structures
+	test1Mongo := m.Mongo{}
+	test1Postgres := m.Postgres{}
+	test1Mongo.Name = "name.first"
+	test1Postgres.Name = "name_first"
+	field := m.Field{}
+	field.Mongo = test1Mongo
+	field.Postgres = test1Postgres
+	nameFirst := m.Fields{"name.first": field}
+	singleNested := map[string]interface{}{"name": map[string]interface{}{"first": "John", "last": "Doe"}}
+	singleNestedResult := map[string]interface{}{"name_first": "John"}
+	var nested = []struct {
+		op     *gtm.Op
+		fields m.Fields
+		result map[string]interface{}
+	}{
+		{&gtm.Op{Operation: "i", Data: singleNested}, nameFirst, singleNestedResult},
+	}
+	for _, t := range nested {
+		actual := m.SanitizeData(t.fields, t.op)
+		c.Check(actual, DeepEquals, t.result)
+	}
 }
 
 func (s *MySuite) TestEnsureOpHasAllFieldsWhenEmpty(c *C) {