Merge pull request #50 from r3labs/v2

merge v2 branch

Author: purehyperbole

README.md

@@ -52,7 +52,7 @@ A diffable value can be/contain any of the following types:
 
 
 | Type         | Supported |
-|--------------|-----------|
+| ------------ | --------- |
 | struct       | ✔         |
 | slice        | ✔         |
 | string       | ✔         |
@@ -69,12 +69,12 @@ Please see the docs for more supported types, options and features.
 
 In order for struct fields to be compared, they must be tagged with a given name. All tag values are prefixed with `diff`. i.e. `diff:"items"`.
 
-| Tag          | Usage                              |
-|--------------|------------------------------------|
-| `-`          | Excludes a value from being diffed |
-| `identifier` | If you need to compare arrays by a matching identifier and not based on order, you can specify the `identifier` tag. If an identifiable element is found in both the from and to structures, they will be directly compared. i.e. `diff:"name, identifier"` |
-| `immutable` | Will omit this struct field from diffing. When using `diff.StructValues()` these values will be added to the returned changelog. It's use case is for when we have nothing to compare a struct to and want to show all of its relevant values. |
-| `nocreate` | The default patch action is to allocate instances in the target strut, map or slice should they not exist. Adding this flag will tell patch to skip elements that it would otherwise need to allocate. This is separate from immutable, which is also honored while patching. |
+| Tag           | Usage                                                                                                                                                                                                                                                                                           |
+| ------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `-`           | Excludes a value from being diffed                                                                                                                                                                                                                                                              |
+| `identifier`  | If you need to compare arrays by a matching identifier and not based on order, you can specify the `identifier` tag. If an identifiable element is found in both the from and to structures, they will be directly compared. i.e. `diff:"name, identifier"`                                     |
+| `immutable`   | Will omit this struct field from diffing. When using `diff.StructValues()` these values will be added to the returned changelog. It's use case is for when we have nothing to compare a struct to and want to show all of its relevant values.                                                  |
+| `nocreate`    | The default patch action is to allocate instances in the target strut, map or slice should they not exist. Adding this flag will tell patch to skip elements that it would otherwise need to allocate. This is separate from immutable, which is also honored while patching.                   |
 | `omitunequal` | Patching is a 'best effort' operation, and will by default attempt to update the 'correct' member of the target even if the underlying value has already changed to something other than the value in the change log 'from'. This tag will selectively ignore values that are not a 100% match. |
 
 ## Usage
@@ -84,7 +84,7 @@ In order for struct fields to be compared, they must be tagged with a given name
 Diffing a basic set of values can be accomplished using the diff functions. Any items that specify a "diff" tag using a name will be compared.
 
 ```go
-import "github.com/r3labs/diff"
+import "github.com/r3labs/diff/v2"
 
 type Order struct {
     ID    string `diff:"id"`
@@ -125,7 +125,7 @@ When marshalling the changelog to json, the output will look like:
 
 Options can be set on the differ at call time which effect how diff acts when building the change log.
 ```go
-import "github.com/r3labs/diff"
+import "github.com/r3labs/diff/v2"
 
 type Order struct {
     ID    string `diff:"id"`
@@ -151,7 +151,7 @@ func main() {
 You can also create a new instance of a differ that allows options to be set.
 
 ```go
-import "github.com/r3labs/diff"
+import "github.com/r3labs/diff/v2"
 
 type Order struct {
     ID    string `diff:"id"`
@@ -169,10 +169,10 @@ func main() {
         Items: []int{1, 2, 4},
     }
 
-	d, err := diff.NewDiffer(diff.SliceOrdering(true))
-	if err != nil {
-		panic(err)
-	}
+    d, err := diff.NewDiffer(diff.SliceOrdering(true))
+    if err != nil {
+        panic(err)
+    }
 
     changelog, err := d.Diff(a, b)
     ...
@@ -205,7 +205,7 @@ To accommodate this patch keeps track of each change log option it attempts to a
 happened for further scrutiny.
 
 ```go
-import "github.com/r3labs/diff"
+import "github.com/r3labs/diff/v2"
 
 type Order struct {
     ID    string `diff:"id"`
@@ -234,11 +234,44 @@ func main() {
 }
 ```
 
+Instances of differ with options set can also be used when patching.
+
+```go
+package main
+
+import "github.com/r3labs/diff/v2"
+
+type Order struct {
+	ID    string `json:"id"`
+	Items []int  `json:"items"`
+}
+
+func main() {
+    a := Order{
+        ID:    "1234",
+        Items: []int{1, 2, 3, 4},
+        }
+
+    b := Order{
+        ID:    "1234",
+        Items: []int{1, 2, 4},
+    }
+
+    d, _ := diff.NewDiffer(diff.TagName("json"))
+
+    changelog, _ := d.Diff(a, b)
+
+    d.Patch(changelog, &a)
+    // reflect.DeepEqual(a, b) == true
+}
+
+```
+
 As a convenience, there is a Merge function that allows one to take three interfaces and perform all the tasks at the same
 time.
 
 ```go
-import "github.com/r3labs/diff"
+import "github.com/r3labs/diff/v2"
 
 type Order struct {
     ID    string `diff:"id"`

change_value.go

@@ -1,6 +1,7 @@
 package diff
 
 import (
+	"fmt"
 	"reflect"
 )
 
@@ -73,14 +74,24 @@ func (c ChangeValue) ParentLen() (ret int) {
 }
 
 //ParentSet - nil safe parent set
-func (c *ChangeValue) ParentSet(value reflect.Value) {
+func (c *ChangeValue) ParentSet(value reflect.Value, convertCompatibleTypes bool) {
 	if c != nil && c.parent != nil {
 		defer func() {
 			if r := recover(); r != nil {
 				c.SetFlag(FlagParentSetFailed)
 			}
 		}()
-		c.parent.Set(value)
+
+		if convertCompatibleTypes {
+			if !value.Type().ConvertibleTo(c.parent.Type()) {
+				c.AddError(fmt.Errorf("Value of type %s is not convertible to %s", value.Type().String(), c.parent.Type().String()))
+				c.SetFlag(FlagParentSetFailed)
+				return
+			}
+			c.parent.Set(value.Convert(c.parent.Type()))
+		} else {
+			c.parent.Set(value)
+		}
 		c.SetFlag(FlagParentSetApplied)
 	}
 }
@@ -91,7 +102,7 @@ func (c ChangeValue) Len() int {
 }
 
 //Set echos reflect set
-func (c *ChangeValue) Set(value reflect.Value) {
+func (c *ChangeValue) Set(value reflect.Value, convertCompatibleTypes bool) {
 	if c != nil {
 		defer func() {
 			if r := recover(); r != nil {
@@ -103,7 +114,17 @@ func (c *ChangeValue) Set(value reflect.Value) {
 			c.SetFlag(FlagIgnored)
 			return
 		}
-		c.target.Set(value)
+
+		if convertCompatibleTypes {
+			if !value.Type().ConvertibleTo(c.target.Type()) {
+				c.AddError(fmt.Errorf("Value of type %s is not convertible to %s", value.Type().String(), c.target.Type().String()))
+				c.SetFlag(FlagFailed)
+				return
+			}
+			c.target.Set(value.Convert(c.target.Type()))
+		} else {
+			c.target.Set(value)
+		}
 		c.SetFlag(FlagApplied)
 	}
 }

diff.go

@@ -7,10 +7,11 @@ package diff
 import (
 	"errors"
 	"fmt"
-	"github.com/vmihailenco/msgpack"
 	"reflect"
 	"strconv"
 	"strings"
+
+	"github.com/vmihailenco/msgpack"
 )
 
 const (
@@ -24,15 +25,17 @@ const (
 
 // Differ a configurable diff instance
 type Differ struct {
-	TagName             string
-	SliceOrdering       bool
-	DisableStructValues bool
-	customValueDiffers  []ValueDiffer
-	cl                  Changelog
-	AllowTypeMismatch   bool
-	DiscardParent       bool
-	StructMapKeys       bool
-	Filter              FilterFunc
+	TagName                string
+	SliceOrdering          bool
+	DisableStructValues    bool
+	customValueDiffers     []ValueDiffer
+	cl                     Changelog
+	AllowTypeMismatch      bool
+	DiscardParent          bool
+	StructMapKeys          bool
+	FlattenEmbeddedStructs bool
+	ConvertCompatibleTypes bool
+	Filter                 FilterFunc
 }
 
 // Changelog stores a list of changed items
@@ -250,11 +253,11 @@ func swapChange(t string, c Change) Change {
 }
 
 func idComplex(v interface{}) string {
-	switch v.(type) {
+	switch v := v.(type) {
 	case string:
-		return v.(string)
+		return v
 	case int:
-		return strconv.Itoa(v.(int))
+		return strconv.Itoa(v)
 	default:
 		b, err := msgpack.Marshal(v)
 		if err != nil {
@@ -265,11 +268,11 @@ func idComplex(v interface{}) string {
 
 }
 func idstring(v interface{}) string {
-	switch v.(type) {
+	switch v := v.(type) {
 	case string:
-		return v.(string)
+		return v
 	case int:
-		return strconv.Itoa(v.(int))
+		return strconv.Itoa(v)
 	default:
 		return fmt.Sprint(v)
 	}

diff_map.go

@@ -6,8 +6,9 @@ package diff
 
 import (
 	"fmt"
-	"github.com/vmihailenco/msgpack"
 	"reflect"
+
+	"github.com/vmihailenco/msgpack"
 )
 
 func (d *Differ) diffMap(path []string, a, b reflect.Value) error {
@@ -57,7 +58,8 @@ func (d *Differ) mapValues(t string, path []string, a reflect.Value) error {
 		if d.StructMapKeys {
 			//it's not enough to turn k to a string, we need to able to  marshal a type when
 			//we apply it in patch so... we'll marshal it to JSON
-			if b, err := msgpack.Marshal(k.Interface()); err == nil {
+			var b []byte
+			if b, err = msgpack.Marshal(k.Interface()); err == nil {
 				err = d.diff(append(path, string(b)), xe, ae, a.Interface())
 			}
 		} else {

diff_slice.go

@@ -90,7 +90,7 @@ type sliceTracker []bool
 
 func (st *sliceTracker) has(s, v reflect.Value) bool {
 	if len(*st) != s.Len() {
-		(*st) = make([]bool, s.Len(), s.Len())
+		(*st) = make([]bool, s.Len())
 	}
 
 	for i := 0; i < s.Len(); i++ {

diff_string.go

@@ -22,7 +22,12 @@ func (d *Differ) diffString(path []string, a, b reflect.Value, parent interface{
 	}
 
 	if a.String() != b.String() {
-		d.cl.Add(UPDATE, path, a.String(), b.String(), parent)
+		if a.CanInterface() {
+			// If a and/or b is of a type that is an alias for String, store that type in changelog
+			d.cl.Add(UPDATE, path, a.Interface(), b.Interface(), parent)
+		} else {
+			d.cl.Add(UPDATE, path, a.String(), b.String(), parent)
+		}
 	}
 
 	return nil

diff_struct.go

@@ -45,7 +45,10 @@ func (d *Differ) diffStruct(path []string, a, b reflect.Value) error {
 		af := a.Field(i)
 		bf := b.FieldByName(field.Name)
 
-		fpath := copyAppend(path, tname)
+		fpath := path
+		if !(d.FlattenEmbeddedStructs && field.Anonymous) {
+			fpath = copyAppend(fpath, tname)
+		}
 
 		if d.Filter != nil && !d.Filter(fpath, a.Type(), field) {
 			continue