pax_global_header00006660000000000000000000000064127377452470014534gustar00rootroot0000000000000052 comment=7b706999d935b04cf2dbc71a5a5afcbd288aeb48 messagediff-1.1.0/000077500000000000000000000000001273774524700140105ustar00rootroot00000000000000messagediff-1.1.0/.coveralls.yml000066400000000000000000000000561273774524700166040ustar00rootroot00000000000000repo_token: LWIe7rP7M3hBnAxpsMaZhrVBs2DSyhzoQ messagediff-1.1.0/.gitignore000066400000000000000000000004121273774524700157750ustar00rootroot00000000000000# Compiled Object files, Static and Dynamic libs (Shared Objects) *.o *.a *.so # Folders _obj _test # Architecture specific extensions/prefixes *.[568vq] [568vq].out *.cgo1.go *.cgo2.c _cgo_defun.c _cgo_gotypes.go _cgo_export.* _testmain.go *.exe *.test *.prof messagediff-1.1.0/.travis.yml000066400000000000000000000010341273774524700161170ustar00rootroot00000000000000language: go os: - linux - osx go: - 1 - 1.3 - 1.4 - 1.5 - 1.6 - tip before_install: - if ! go get github.com/golang/tools/cmd/cover; then go get golang.org/x/tools/cmd/cover; fi - go get github.com/axw/gocov/gocov - go get github.com/modocache/gover - go get github.com/mattn/goveralls script: - go test -v -coverprofile=example.coverprofile ./example - go test -v -coverprofile=main.coverprofile - $HOME/gopath/bin/gover - $HOME/gopath/bin/goveralls -service=travis-ci -coverprofile=gover.coverprofile messagediff-1.1.0/CHANGELOG.md000066400000000000000000000004011273774524700156140ustar00rootroot00000000000000## v1.1.0 * Added support for recursive data structures. * Fixed bug with embedded fixed length arrays in structs. * Added `example/` directory. * Minor test bug fixes for future go versions. * Added change log. ## v1.0.0 Initial tagged release release. messagediff-1.1.0/LICENSE000066400000000000000000000020701273774524700150140ustar00rootroot00000000000000The MIT License (MIT) Copyright (c) 2015 Tristan Rice Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. messagediff-1.1.0/README.md000066400000000000000000000033751273774524700152770ustar00rootroot00000000000000# messagediff [![Build Status](https://travis-ci.org/d4l3k/messagediff.svg?branch=master)](https://travis-ci.org/d4l3k/messagediff) [![Coverage Status](https://coveralls.io/repos/github/d4l3k/messagediff/badge.svg?branch=master)](https://coveralls.io/github/d4l3k/messagediff?branch=master) [![GoDoc](https://godoc.org/github.com/d4l3k/messagediff?status.svg)](https://godoc.org/github.com/d4l3k/messagediff) A library for doing diffs of arbitrary Golang structs. If the unsafe package is available messagediff will diff unexported fields in addition to exported fields. This is primarily used for testing purposes as it allows for providing informative error messages. ## Example Usage In a normal file: ```go package main import "gopkg.in/d4l3k/messagediff.v1" type someStruct struct { A, b int C []int } func main() { a := someStruct{1, 2, []int{1}} b := someStruct{1, 3, []int{1, 2}} diff, equal := messagediff.PrettyDiff(a, b) /* diff = `added: .C[1] = 2 modified: .b = 3` equal = false */ } ``` In a test: ```go import "gopkg.in/d4l3k/messagediff.v1" ... type someStruct struct { A, b int C []int } func TestSomething(t *testing.T) { want := someStruct{1, 2, []int{1}} got := someStruct{1, 3, []int{1, 2}} if diff, equal := messagediff.PrettyDiff(want, got); !equal { t.Errorf("Something() = %#v\n%s", got, diff) } } ``` See the `DeepDiff` function for using the diff results programmatically. ## License Copyright (c) 2015 [Tristan Rice](https://fn.lc) messagediff is licensed under the MIT license. See the LICENSE file for more information. bypass.go and bypasssafe.go are borrowed from [go-spew](https://github.com/davecgh/go-spew) and have a seperate copyright notice. messagediff-1.1.0/bypass.go000066400000000000000000000131001273774524700156330ustar00rootroot00000000000000// Copyright (c) 2015 Dave Collins // // Permission to use, copy, modify, and distribute this software for any // purpose with or without fee is hereby granted, provided that the above // copyright notice and this permission notice appear in all copies. // // THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES // WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF // MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR // ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES // WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN // ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF // OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. // NOTE: Due to the following build constraints, this file will only be compiled // when the code is not running on Google App Engine and "-tags disableunsafe" // is not added to the go build command line. // +build !appengine,!disableunsafe package messagediff import ( "reflect" "unsafe" ) const ( // UnsafeDisabled is a build-time constant which specifies whether or // not access to the unsafe package is available. UnsafeDisabled = false // ptrSize is the size of a pointer on the current arch. ptrSize = unsafe.Sizeof((*byte)(nil)) ) var ( // offsetPtr, offsetScalar, and offsetFlag are the offsets for the // internal reflect.Value fields. These values are valid before golang // commit ecccf07e7f9d which changed the format. The are also valid // after commit 82f48826c6c7 which changed the format again to mirror // the original format. Code in the init function updates these offsets // as necessary. offsetPtr = uintptr(ptrSize) offsetScalar = uintptr(0) offsetFlag = uintptr(ptrSize * 2) // flagKindWidth and flagKindShift indicate various bits that the // reflect package uses internally to track kind information. // // flagRO indicates whether or not the value field of a reflect.Value is // read-only. // // flagIndir indicates whether the value field of a reflect.Value is // the actual data or a pointer to the data. // // These values are valid before golang commit 90a7c3c86944 which // changed their positions. Code in the init function updates these // flags as necessary. flagKindWidth = uintptr(5) flagKindShift = uintptr(flagKindWidth - 1) flagRO = uintptr(1 << 0) flagIndir = uintptr(1 << 1) ) func init() { // Older versions of reflect.Value stored small integers directly in the // ptr field (which is named val in the older versions). Versions // between commits ecccf07e7f9d and 82f48826c6c7 added a new field named // scalar for this purpose which unfortunately came before the flag // field, so the offset of the flag field is different for those // versions. // // This code constructs a new reflect.Value from a known small integer // and checks if the size of the reflect.Value struct indicates it has // the scalar field. When it does, the offsets are updated accordingly. vv := reflect.ValueOf(0xf00) if unsafe.Sizeof(vv) == (ptrSize * 4) { offsetScalar = ptrSize * 2 offsetFlag = ptrSize * 3 } // Commit 90a7c3c86944 changed the flag positions such that the low // order bits are the kind. This code extracts the kind from the flags // field and ensures it's the correct type. When it's not, the flag // order has been changed to the newer format, so the flags are updated // accordingly. upf := unsafe.Pointer(uintptr(unsafe.Pointer(&vv)) + offsetFlag) upfv := *(*uintptr)(upf) flagKindMask := uintptr((1<>flagKindShift != uintptr(reflect.Int) { flagKindShift = 0 flagRO = 1 << 5 flagIndir = 1 << 6 // Commit adf9b30e5594 modified the flags to separate the // flagRO flag into two bits which specifies whether or not the // field is embedded. This causes flagIndir to move over a bit // and means that flagRO is the combination of either of the // original flagRO bit and the new bit. // // This code detects the change by extracting what used to be // the indirect bit to ensure it's set. When it's not, the flag // order has been changed to the newer format, so the flags are // updated accordingly. if upfv&flagIndir == 0 { flagRO = 3 << 5 flagIndir = 1 << 7 } } } // unsafeReflectValue converts the passed reflect.Value into a one that bypasses // the typical safety restrictions preventing access to unaddressable and // unexported data. It works by digging the raw pointer to the underlying // value out of the protected value and generating a new unprotected (unsafe) // reflect.Value to it. // // This allows us to check for implementations of the Stringer and error // interfaces to be used for pretty printing ordinarily unaddressable and // inaccessible values such as unexported struct fields. func unsafeReflectValue(v reflect.Value) (rv reflect.Value) { indirects := 1 vt := v.Type() upv := unsafe.Pointer(uintptr(unsafe.Pointer(&v)) + offsetPtr) rvf := *(*uintptr)(unsafe.Pointer(uintptr(unsafe.Pointer(&v)) + offsetFlag)) if rvf&flagIndir != 0 { vt = reflect.PtrTo(v.Type()) indirects++ } else if offsetScalar != 0 { // The value is in the scalar field when it's not one of the // reference types. switch vt.Kind() { case reflect.Uintptr: case reflect.Chan: case reflect.Func: case reflect.Map: case reflect.Ptr: case reflect.UnsafePointer: default: upv = unsafe.Pointer(uintptr(unsafe.Pointer(&v)) + offsetScalar) } } pv := reflect.NewAt(vt, upv) rv = pv for i := 0; i < indirects; i++ { rv = rv.Elem() } return rv } messagediff-1.1.0/bypasssafe.go000066400000000000000000000031621273774524700165010ustar00rootroot00000000000000// Copyright (c) 2015 Dave Collins // // Permission to use, copy, modify, and distribute this software for any // purpose with or without fee is hereby granted, provided that the above // copyright notice and this permission notice appear in all copies. // // THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES // WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF // MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR // ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES // WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN // ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF // OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. // NOTE: Due to the following build constraints, this file will only be compiled // when either the code is running on Google App Engine or "-tags disableunsafe" // is added to the go build command line. // +build appengine disableunsafe package messagediff import "reflect" const ( // UnsafeDisabled is a build-time constant which specifies whether or // not access to the unsafe package is available. UnsafeDisabled = true ) // unsafeReflectValue typically converts the passed reflect.Value into a one // that bypasses the typical safety restrictions preventing access to // unaddressable and unexported data. However, doing this relies on access to // the unsafe package. This is a stub version which simply returns the passed // reflect.Value when the unsafe package is not available. func unsafeReflectValue(v reflect.Value) reflect.Value { return v } messagediff-1.1.0/example/000077500000000000000000000000001273774524700154435ustar00rootroot00000000000000messagediff-1.1.0/example/atom_test.go000066400000000000000000000022711273774524700177730ustar00rootroot00000000000000package examples import ( "fmt" "github.com/d4l3k/messagediff" "golang.org/x/net/html" "golang.org/x/net/html/atom" ) func ExampleAtom() { got := data2() want := data1() diff, equal := messagediff.PrettyDiff(want, got) fmt.Printf("%v %s", equal, diff) // Output: false modified: [0].FirstChild.NextSibling.Attr = " baz" } func data1() []*html.Node { n := &html.Node{ Type: html.ElementNode, Data: atom.Span.String(), Attr: []html.Attribute{ {Key: atom.Class.String(), Val: "foo"}, }, } n.AppendChild( &html.Node{ Type: html.ElementNode, Data: atom.Span.String(), Attr: []html.Attribute{ {Key: atom.Class.String(), Val: "bar"}, }, }, ) n.AppendChild(&html.Node{ Type: html.TextNode, Data: "baz", }) return []*html.Node{n} } func data2() []*html.Node { n := &html.Node{ Type: html.ElementNode, Data: atom.Span.String(), Attr: []html.Attribute{ {Key: atom.Class.String(), Val: "foo"}, }, } n.AppendChild( &html.Node{ Type: html.ElementNode, Data: atom.Span.String(), Attr: []html.Attribute{ {Key: atom.Class.String(), Val: "bar"}, }, }, ) n.AppendChild(&html.Node{ Type: html.TextNode, Data: " baz", }) return []*html.Node{n} } messagediff-1.1.0/example/example.go000066400000000000000000000000211273774524700174160ustar00rootroot00000000000000package examples messagediff-1.1.0/messagediff.go000066400000000000000000000131731273774524700166210ustar00rootroot00000000000000package messagediff import ( "fmt" "reflect" "sort" "strings" "unsafe" ) // PrettyDiff does a deep comparison and returns the nicely formated results. func PrettyDiff(a, b interface{}) (string, bool) { d, equal := DeepDiff(a, b) var dstr []string for path, added := range d.Added { dstr = append(dstr, fmt.Sprintf("added: %s = %#v\n", path.String(), added)) } for path, removed := range d.Removed { dstr = append(dstr, fmt.Sprintf("removed: %s = %#v\n", path.String(), removed)) } for path, modified := range d.Modified { dstr = append(dstr, fmt.Sprintf("modified: %s = %#v\n", path.String(), modified)) } sort.Strings(dstr) return strings.Join(dstr, ""), equal } // DeepDiff does a deep comparison and returns the results. func DeepDiff(a, b interface{}) (*Diff, bool) { d := newDiff() return d, d.diff(reflect.ValueOf(a), reflect.ValueOf(b), nil) } func newDiff() *Diff { return &Diff{ Added: make(map[*Path]interface{}), Removed: make(map[*Path]interface{}), Modified: make(map[*Path]interface{}), visited: make(map[visit]bool), } } func (d *Diff) diff(aVal, bVal reflect.Value, path Path) bool { // Validity checks. Should only trigger if nil is one of the original arguments. if !aVal.IsValid() && !bVal.IsValid() { return true } if !bVal.IsValid() { d.Modified[&path] = nil return false } else if !aVal.IsValid() { d.Modified[&path] = bVal.Interface() return false } if aVal.Type() != bVal.Type() { d.Modified[&path] = bVal.Interface() return false } kind := aVal.Kind() // Borrowed from the reflect package to handle recursive data structures. hard := func(k reflect.Kind) bool { switch k { case reflect.Array, reflect.Map, reflect.Slice, reflect.Struct: return true } return false } if aVal.CanAddr() && bVal.CanAddr() && hard(kind) { addr1 := unsafe.Pointer(aVal.UnsafeAddr()) addr2 := unsafe.Pointer(bVal.UnsafeAddr()) if uintptr(addr1) > uintptr(addr2) { // Canonicalize order to reduce number of entries in visited. // Assumes non-moving garbage collector. addr1, addr2 = addr2, addr1 } // Short circuit if references are already seen. typ := aVal.Type() v := visit{addr1, addr2, typ} if d.visited[v] { return true } // Remember for later. d.visited[v] = true } // End of borrowed code. equal := true switch kind { case reflect.Map, reflect.Ptr, reflect.Func, reflect.Chan, reflect.Slice: if aVal.IsNil() && bVal.IsNil() { return true } if aVal.IsNil() || bVal.IsNil() { d.Modified[&path] = bVal.Interface() return false } } switch kind { case reflect.Array, reflect.Slice: aLen := aVal.Len() bLen := bVal.Len() for i := 0; i < min(aLen, bLen); i++ { localPath := append(path, SliceIndex(i)) if eq := d.diff(aVal.Index(i), bVal.Index(i), localPath); !eq { equal = false } } if aLen > bLen { for i := bLen; i < aLen; i++ { localPath := append(path, SliceIndex(i)) d.Removed[&localPath] = aVal.Index(i).Interface() equal = false } } else if aLen < bLen { for i := aLen; i < bLen; i++ { localPath := append(path, SliceIndex(i)) d.Added[&localPath] = bVal.Index(i).Interface() equal = false } } case reflect.Map: for _, key := range aVal.MapKeys() { aI := aVal.MapIndex(key) bI := bVal.MapIndex(key) localPath := append(path, MapKey{key.Interface()}) if !bI.IsValid() { d.Removed[&localPath] = aI.Interface() equal = false } else if eq := d.diff(aI, bI, localPath); !eq { equal = false } } for _, key := range bVal.MapKeys() { aI := aVal.MapIndex(key) if !aI.IsValid() { bI := bVal.MapIndex(key) localPath := append(path, MapKey{key.Interface()}) d.Added[&localPath] = bI.Interface() equal = false } } case reflect.Struct: typ := aVal.Type() for i := 0; i < typ.NumField(); i++ { index := []int{i} field := typ.FieldByIndex(index) localPath := append(path, StructField(field.Name)) aI := unsafeReflectValue(aVal.FieldByIndex(index)) bI := unsafeReflectValue(bVal.FieldByIndex(index)) if eq := d.diff(aI, bI, localPath); !eq { equal = false } } case reflect.Ptr: equal = d.diff(aVal.Elem(), bVal.Elem(), path) default: if reflect.DeepEqual(aVal.Interface(), bVal.Interface()) { equal = true } else { d.Modified[&path] = bVal.Interface() equal = false } } return equal } func min(a, b int) int { if a < b { return a } return b } // During deepValueEqual, must keep track of checks that are // in progress. The comparison algorithm assumes that all // checks in progress are true when it reencounters them. // Visited comparisons are stored in a map indexed by visit. // This is borrowed from the reflect package. type visit struct { a1 unsafe.Pointer a2 unsafe.Pointer typ reflect.Type } // Diff represents a change in a struct. type Diff struct { Added, Removed, Modified map[*Path]interface{} visited map[visit]bool } // Path represents a path to a changed datum. type Path []PathNode func (p Path) String() string { var out string for _, n := range p { out += n.String() } return out } // PathNode represents one step in the path. type PathNode interface { String() string } // StructField is a path element representing a field of a struct. type StructField string func (n StructField) String() string { return fmt.Sprintf(".%s", string(n)) } // MapKey is a path element representing a key of a map. type MapKey struct { Key interface{} } func (n MapKey) String() string { return fmt.Sprintf("[%#v]", n.Key) } // SliceIndex is a path element representing a index of a slice. type SliceIndex int func (n SliceIndex) String() string { return fmt.Sprintf("[%d]", n) } messagediff-1.1.0/messagediff_test.go000066400000000000000000000052211273774524700176530ustar00rootroot00000000000000package messagediff import ( "testing" "time" ) type testStruct struct { A, b int C []int D [3]int } type RecursiveStruct struct { Key int Child *RecursiveStruct } func newRecursiveStruct(key int) *RecursiveStruct { a := &RecursiveStruct{ Key: key, } b := &RecursiveStruct{ Key: key, Child: a, } a.Child = b return a } type testCase struct { a, b interface{} diff string equal bool } func checkTestCases(t *testing.T, testData []testCase) { for i, td := range testData { diff, equal := PrettyDiff(td.a, td.b) if diff != td.diff { t.Errorf("%d. PrettyDiff(%#v, %#v) diff = %#v; not %#v", i, td.a, td.b, diff, td.diff) } if equal != td.equal { t.Errorf("%d. PrettyDiff(%#v, %#v) equal = %#v; not %#v", i, td.a, td.b, equal, td.equal) } } } func TestPrettyDiff(t *testing.T) { testData := []testCase{ { true, false, "modified: = false\n", false, }, { true, 0, "modified: = 0\n", false, }, { []int{0, 1, 2}, []int{0, 1, 2, 3}, "added: [3] = 3\n", false, }, { []int{0, 1, 2, 3}, []int{0, 1, 2}, "removed: [3] = 3\n", false, }, { []int{0}, []int{1}, "modified: [0] = 1\n", false, }, { &[]int{0}, &[]int{1}, "modified: [0] = 1\n", false, }, { map[string]int{"a": 1, "b": 2}, map[string]int{"b": 4, "c": 3}, "added: [\"c\"] = 3\nmodified: [\"b\"] = 4\nremoved: [\"a\"] = 1\n", false, }, { testStruct{1, 2, []int{1}, [3]int{4, 5, 6}}, testStruct{1, 3, []int{1, 2}, [3]int{4, 5, 6}}, "added: .C[1] = 2\nmodified: .b = 3\n", false, }, { nil, nil, "", true, }, { &struct{}{}, nil, "modified: = \n", false, }, { nil, &struct{}{}, "modified: = &struct {}{}\n", false, }, { time.Time{}, time.Time{}, "", true, }, { time.Date(1970, 1, 1, 0, 0, 0, 0, time.UTC), time.Time{}, "modified: .loc = (*time.Location)(nil)\nmodified: .sec = 0\n", false, }, } checkTestCases(t, testData) } func TestPrettyDiffRecursive(t *testing.T) { testData := []testCase{ { newRecursiveStruct(1), newRecursiveStruct(1), "", true, }, { newRecursiveStruct(1), newRecursiveStruct(2), "modified: .Child.Key = 2\nmodified: .Key = 2\n", false, }, } checkTestCases(t, testData) } func TestPathString(t *testing.T) { testData := []struct { in Path want string }{{ Path{StructField("test"), SliceIndex(1), MapKey{"blue"}, MapKey{12.3}}, ".test[1][\"blue\"][12.3]", }} for i, td := range testData { if out := td.in.String(); out != td.want { t.Errorf("%d. %#v.String() = %#v; not %#v", i, td.in, out, td.want) } } }