Remove old diffing utility packages
This commit is contained in:
Tobie Morgan Hitchcock
parent
244645ac0c
commit
a460ee4a06
5 changed files with 0 additions and 1441 deletions
|
|
@ -1,461 +0,0 @@
|
||||||
package diff
|
|
||||||
|
|
||||||
import (
|
|
||||||
"errors"
|
|
||||||
dmp "github.com/sergi/go-diff/diffmatchpatch"
|
|
||||||
"reflect"
|
|
||||||
"strconv"
|
|
||||||
)
|
|
||||||
|
|
||||||
// A Delta represents an atomic difference between two JSON objects.
|
|
||||||
type Delta interface {
|
|
||||||
// Similarity calculates the similarity of the Delta values.
|
|
||||||
// The return value is normalized from 0 to 1,
|
|
||||||
// 0 is completely different and 1 is they are same
|
|
||||||
Similarity() (similarity float64)
|
|
||||||
}
|
|
||||||
|
|
||||||
// To cache the calculated similarity,
|
|
||||||
// concrete Deltas can use similariter and similarityCache
|
|
||||||
type similariter interface {
|
|
||||||
similarity() (similarity float64)
|
|
||||||
}
|
|
||||||
|
|
||||||
type similarityCache struct {
|
|
||||||
similariter
|
|
||||||
value float64
|
|
||||||
}
|
|
||||||
|
|
||||||
func newSimilarityCache(sim similariter) similarityCache {
|
|
||||||
cache := similarityCache{similariter: sim, value: -1}
|
|
||||||
return cache
|
|
||||||
}
|
|
||||||
|
|
||||||
func (cache similarityCache) Similarity() (similarity float64) {
|
|
||||||
if cache.value < 0 {
|
|
||||||
cache.value = cache.similariter.similarity()
|
|
||||||
}
|
|
||||||
return cache.value
|
|
||||||
}
|
|
||||||
|
|
||||||
// A Position represents the position of a Delta in an object or an array.
|
|
||||||
type Position interface {
|
|
||||||
// String returns the position as a string
|
|
||||||
String() (name string)
|
|
||||||
|
|
||||||
// CompareTo returns a true if the Position is smaller than another Position.
|
|
||||||
// This function is used to sort Positions by the sort package.
|
|
||||||
CompareTo(another Position) bool
|
|
||||||
}
|
|
||||||
|
|
||||||
// A Name is a Postition with a string, which means the delta is in an object.
|
|
||||||
type Name string
|
|
||||||
|
|
||||||
func (n Name) String() (name string) {
|
|
||||||
return string(n)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (n Name) CompareTo(another Position) bool {
|
|
||||||
return n < another.(Name)
|
|
||||||
}
|
|
||||||
|
|
||||||
// A Index is a Position with an int value, which means the Delta is in an Array.
|
|
||||||
type Index int
|
|
||||||
|
|
||||||
func (i Index) String() (name string) {
|
|
||||||
return strconv.Itoa(int(i))
|
|
||||||
}
|
|
||||||
|
|
||||||
func (i Index) CompareTo(another Position) bool {
|
|
||||||
return i < another.(Index)
|
|
||||||
}
|
|
||||||
|
|
||||||
// A PreDelta is a Delta that has a position of the left side JSON object.
|
|
||||||
// Deltas implements this interface should be applies before PostDeltas.
|
|
||||||
type PreDelta interface {
|
|
||||||
// PrePosition returns the Position.
|
|
||||||
PrePosition() Position
|
|
||||||
|
|
||||||
// PreApply applies the delta to object.
|
|
||||||
PreApply(object interface{}) interface{}
|
|
||||||
}
|
|
||||||
|
|
||||||
type preDelta struct{ Position }
|
|
||||||
|
|
||||||
func (i preDelta) PrePosition() Position {
|
|
||||||
return Position(i.Position)
|
|
||||||
}
|
|
||||||
|
|
||||||
type preDeltas []PreDelta
|
|
||||||
|
|
||||||
// for sorting
|
|
||||||
func (s preDeltas) Len() int {
|
|
||||||
return len(s)
|
|
||||||
}
|
|
||||||
|
|
||||||
// for sorting
|
|
||||||
func (s preDeltas) Swap(i, j int) {
|
|
||||||
s[i], s[j] = s[j], s[i]
|
|
||||||
}
|
|
||||||
|
|
||||||
// for sorting
|
|
||||||
func (s preDeltas) Less(i, j int) bool {
|
|
||||||
return !s[i].PrePosition().CompareTo(s[j].PrePosition())
|
|
||||||
}
|
|
||||||
|
|
||||||
// A PreDelta is a Delta that has a position of the right side JSON object.
|
|
||||||
// Deltas implements this interface should be applies after PreDeltas.
|
|
||||||
type PostDelta interface {
|
|
||||||
// PostPosition returns the Position.
|
|
||||||
PostPosition() Position
|
|
||||||
|
|
||||||
// PostApply applies the delta to object.
|
|
||||||
PostApply(object interface{}) interface{}
|
|
||||||
}
|
|
||||||
|
|
||||||
type postDelta struct{ Position }
|
|
||||||
|
|
||||||
func (i postDelta) PostPosition() Position {
|
|
||||||
return Position(i.Position)
|
|
||||||
}
|
|
||||||
|
|
||||||
type postDeltas []PostDelta
|
|
||||||
|
|
||||||
// for sorting
|
|
||||||
func (s postDeltas) Len() int {
|
|
||||||
return len(s)
|
|
||||||
}
|
|
||||||
|
|
||||||
// for sorting
|
|
||||||
func (s postDeltas) Swap(i, j int) {
|
|
||||||
s[i], s[j] = s[j], s[i]
|
|
||||||
}
|
|
||||||
|
|
||||||
// for sorting
|
|
||||||
func (s postDeltas) Less(i, j int) bool {
|
|
||||||
return s[i].PostPosition().CompareTo(s[j].PostPosition())
|
|
||||||
}
|
|
||||||
|
|
||||||
// An Object is a Delta that represents an object of JSON
|
|
||||||
type Object struct {
|
|
||||||
postDelta
|
|
||||||
similarityCache
|
|
||||||
|
|
||||||
// Deltas holds internal Deltas
|
|
||||||
Deltas []Delta
|
|
||||||
}
|
|
||||||
|
|
||||||
// NewObject returns an Object
|
|
||||||
func NewObject(position Position, deltas []Delta) *Object {
|
|
||||||
d := Object{postDelta: postDelta{position}, Deltas: deltas}
|
|
||||||
d.similarityCache = newSimilarityCache(&d)
|
|
||||||
return &d
|
|
||||||
}
|
|
||||||
|
|
||||||
func (d *Object) PostApply(object interface{}) interface{} {
|
|
||||||
switch object.(type) {
|
|
||||||
case map[string]interface{}:
|
|
||||||
o := object.(map[string]interface{})
|
|
||||||
n := string(d.PostPosition().(Name))
|
|
||||||
o[n] = applyDeltas(d.Deltas, o[n])
|
|
||||||
case []interface{}:
|
|
||||||
o := object.([]interface{})
|
|
||||||
n := int(d.PostPosition().(Index))
|
|
||||||
o[n] = applyDeltas(d.Deltas, o[n])
|
|
||||||
}
|
|
||||||
return object
|
|
||||||
}
|
|
||||||
|
|
||||||
func (d *Object) similarity() (similarity float64) {
|
|
||||||
similarity = deltasSimilarity(d.Deltas)
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
// An Array is a Delta that represents an array of JSON
|
|
||||||
type Array struct {
|
|
||||||
postDelta
|
|
||||||
similarityCache
|
|
||||||
|
|
||||||
// Deltas holds internal Deltas
|
|
||||||
Deltas []Delta
|
|
||||||
}
|
|
||||||
|
|
||||||
// NewArray returns an Array
|
|
||||||
func NewArray(position Position, deltas []Delta) *Array {
|
|
||||||
d := Array{postDelta: postDelta{position}, Deltas: deltas}
|
|
||||||
d.similarityCache = newSimilarityCache(&d)
|
|
||||||
return &d
|
|
||||||
}
|
|
||||||
|
|
||||||
func (d *Array) PostApply(object interface{}) interface{} {
|
|
||||||
switch object.(type) {
|
|
||||||
case map[string]interface{}:
|
|
||||||
o := object.(map[string]interface{})
|
|
||||||
n := string(d.PostPosition().(Name))
|
|
||||||
o[n] = applyDeltas(d.Deltas, o[n])
|
|
||||||
case []interface{}:
|
|
||||||
o := object.([]interface{})
|
|
||||||
n := int(d.PostPosition().(Index))
|
|
||||||
o[n] = applyDeltas(d.Deltas, o[n])
|
|
||||||
}
|
|
||||||
return object
|
|
||||||
}
|
|
||||||
|
|
||||||
func (d *Array) similarity() (similarity float64) {
|
|
||||||
similarity = deltasSimilarity(d.Deltas)
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
// An Added represents a new added field of an object or an array
|
|
||||||
type Added struct {
|
|
||||||
postDelta
|
|
||||||
similarityCache
|
|
||||||
|
|
||||||
// Values holds the added value
|
|
||||||
Value interface{}
|
|
||||||
}
|
|
||||||
|
|
||||||
// NewAdded returns a new Added
|
|
||||||
func NewAdded(position Position, value interface{}) *Added {
|
|
||||||
d := Added{postDelta: postDelta{position}, Value: value}
|
|
||||||
return &d
|
|
||||||
}
|
|
||||||
|
|
||||||
func (d *Added) PostApply(object interface{}) interface{} {
|
|
||||||
switch object.(type) {
|
|
||||||
case map[string]interface{}:
|
|
||||||
object.(map[string]interface{})[string(d.PostPosition().(Name))] = d.Value
|
|
||||||
case []interface{}:
|
|
||||||
i := int(d.PostPosition().(Index))
|
|
||||||
o := object.([]interface{})
|
|
||||||
if i < len(o) {
|
|
||||||
o = append(o, 0) //dummy
|
|
||||||
copy(o[i+1:], o[i:])
|
|
||||||
o[i] = d.Value
|
|
||||||
object = o
|
|
||||||
} else {
|
|
||||||
object = append(o, d.Value)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
return object
|
|
||||||
}
|
|
||||||
|
|
||||||
func (d *Added) similarity() (similarity float64) {
|
|
||||||
return 0
|
|
||||||
}
|
|
||||||
|
|
||||||
// A Modified represents a field whose value is changed.
|
|
||||||
type Modified struct {
|
|
||||||
postDelta
|
|
||||||
similarityCache
|
|
||||||
|
|
||||||
// The value before modification
|
|
||||||
OldValue interface{}
|
|
||||||
|
|
||||||
// The value after modification
|
|
||||||
NewValue interface{}
|
|
||||||
}
|
|
||||||
|
|
||||||
// NewModified returns a Modified
|
|
||||||
func NewModified(position Position, oldValue, newValue interface{}) *Modified {
|
|
||||||
d := Modified{
|
|
||||||
postDelta: postDelta{position},
|
|
||||||
OldValue: oldValue,
|
|
||||||
NewValue: newValue,
|
|
||||||
}
|
|
||||||
d.similarityCache = newSimilarityCache(&d)
|
|
||||||
return &d
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
func (d *Modified) PostApply(object interface{}) interface{} {
|
|
||||||
switch object.(type) {
|
|
||||||
case map[string]interface{}:
|
|
||||||
// TODO check old value
|
|
||||||
object.(map[string]interface{})[string(d.PostPosition().(Name))] = d.NewValue
|
|
||||||
case []interface{}:
|
|
||||||
object.([]interface{})[int(d.PostPosition().(Index))] = d.NewValue
|
|
||||||
}
|
|
||||||
return object
|
|
||||||
}
|
|
||||||
|
|
||||||
func (d *Modified) similarity() (similarity float64) {
|
|
||||||
similarity += 0.3 // at least, they are at the same position
|
|
||||||
if reflect.TypeOf(d.OldValue) == reflect.TypeOf(d.NewValue) {
|
|
||||||
similarity += 0.3 // types are same
|
|
||||||
|
|
||||||
switch d.OldValue.(type) {
|
|
||||||
case string:
|
|
||||||
similarity += 0.4 * stringSimilarity(d.OldValue.(string), d.NewValue.(string))
|
|
||||||
case float64:
|
|
||||||
ratio := d.OldValue.(float64) / d.NewValue.(float64)
|
|
||||||
if ratio > 1 {
|
|
||||||
ratio = 1 / ratio
|
|
||||||
}
|
|
||||||
similarity += 0.4 * ratio
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
// A TextDiff represents a Modified with TextDiff between the old and the new values.
|
|
||||||
type TextDiff struct {
|
|
||||||
Modified
|
|
||||||
|
|
||||||
// Diff string
|
|
||||||
Diff []dmp.Patch
|
|
||||||
}
|
|
||||||
|
|
||||||
// NewTextDiff returns
|
|
||||||
func NewTextDiff(position Position, diff []dmp.Patch, oldValue, newValue interface{}) *TextDiff {
|
|
||||||
d := TextDiff{
|
|
||||||
Modified: *NewModified(position, oldValue, newValue),
|
|
||||||
Diff: diff,
|
|
||||||
}
|
|
||||||
return &d
|
|
||||||
}
|
|
||||||
|
|
||||||
func (d *TextDiff) PostApply(object interface{}) interface{} {
|
|
||||||
switch object.(type) {
|
|
||||||
case map[string]interface{}:
|
|
||||||
o := object.(map[string]interface{})
|
|
||||||
i := string(d.PostPosition().(Name))
|
|
||||||
// TODO error
|
|
||||||
d.OldValue = o[i]
|
|
||||||
// TODO error
|
|
||||||
d.patch()
|
|
||||||
o[i] = d.NewValue
|
|
||||||
case []interface{}:
|
|
||||||
o := object.([]interface{})
|
|
||||||
i := d.PostPosition().(Index)
|
|
||||||
d.OldValue = o[i]
|
|
||||||
// TODO error
|
|
||||||
d.patch()
|
|
||||||
o[i] = d.NewValue
|
|
||||||
}
|
|
||||||
return object
|
|
||||||
}
|
|
||||||
|
|
||||||
func (d *TextDiff) patch() error {
|
|
||||||
if d.OldValue == nil {
|
|
||||||
return errors.New("Old Value is not set")
|
|
||||||
}
|
|
||||||
patcher := dmp.New()
|
|
||||||
patched, successes := patcher.PatchApply(d.Diff, d.OldValue.(string))
|
|
||||||
for _, success := range successes {
|
|
||||||
if !success {
|
|
||||||
return errors.New("Failed to apply a patch")
|
|
||||||
}
|
|
||||||
}
|
|
||||||
d.NewValue = patched
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func (d *TextDiff) DiffString() string {
|
|
||||||
dmp := dmp.New()
|
|
||||||
return dmp.PatchToText(d.Diff)
|
|
||||||
}
|
|
||||||
|
|
||||||
// A Delted represents deleted field or index of an Object or an Array.
|
|
||||||
type Deleted struct {
|
|
||||||
preDelta
|
|
||||||
|
|
||||||
// The value deleted
|
|
||||||
Value interface{}
|
|
||||||
}
|
|
||||||
|
|
||||||
// NewDeleted returns a Deleted
|
|
||||||
func NewDeleted(position Position, value interface{}) *Deleted {
|
|
||||||
d := Deleted{
|
|
||||||
preDelta: preDelta{position},
|
|
||||||
Value: value,
|
|
||||||
}
|
|
||||||
return &d
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
func (d *Deleted) PreApply(object interface{}) interface{} {
|
|
||||||
switch object.(type) {
|
|
||||||
case map[string]interface{}:
|
|
||||||
// TODO check old value
|
|
||||||
delete(object.(map[string]interface{}), string(d.PrePosition().(Name)))
|
|
||||||
case []interface{}:
|
|
||||||
i := int(d.PrePosition().(Index))
|
|
||||||
o := object.([]interface{})
|
|
||||||
object = append(o[:i], o[i+1:]...)
|
|
||||||
}
|
|
||||||
return object
|
|
||||||
}
|
|
||||||
|
|
||||||
func (d Deleted) Similarity() (similarity float64) {
|
|
||||||
return 0
|
|
||||||
}
|
|
||||||
|
|
||||||
// A Moved represents field that is moved, which means the index or name is
|
|
||||||
// changed. Note that, in this library, assigning a Moved and a Modified to
|
|
||||||
// a single position is not allowed. For the compatibility with jsondiffpatch,
|
|
||||||
// the Moved in this library can hold the old and new value in it.
|
|
||||||
type Moved struct {
|
|
||||||
preDelta
|
|
||||||
postDelta
|
|
||||||
similarityCache
|
|
||||||
// The value before moving
|
|
||||||
Value interface{}
|
|
||||||
// The delta applied after moving (for compatibility)
|
|
||||||
Delta interface{}
|
|
||||||
}
|
|
||||||
|
|
||||||
func NewMoved(oldPosition Position, newPosition Position, value interface{}, delta Delta) *Moved {
|
|
||||||
d := Moved{
|
|
||||||
preDelta: preDelta{oldPosition},
|
|
||||||
postDelta: postDelta{newPosition},
|
|
||||||
Value: value,
|
|
||||||
Delta: delta,
|
|
||||||
}
|
|
||||||
d.similarityCache = newSimilarityCache(&d)
|
|
||||||
return &d
|
|
||||||
}
|
|
||||||
|
|
||||||
func (d *Moved) PreApply(object interface{}) interface{} {
|
|
||||||
switch object.(type) {
|
|
||||||
case map[string]interface{}:
|
|
||||||
//not supported
|
|
||||||
case []interface{}:
|
|
||||||
i := int(d.PrePosition().(Index))
|
|
||||||
o := object.([]interface{})
|
|
||||||
d.Value = o[i]
|
|
||||||
object = append(o[:i], o[i+1:]...)
|
|
||||||
}
|
|
||||||
return object
|
|
||||||
}
|
|
||||||
|
|
||||||
func (d *Moved) PostApply(object interface{}) interface{} {
|
|
||||||
switch object.(type) {
|
|
||||||
case map[string]interface{}:
|
|
||||||
//not supported
|
|
||||||
case []interface{}:
|
|
||||||
i := int(d.PostPosition().(Index))
|
|
||||||
o := object.([]interface{})
|
|
||||||
o = append(o, 0) //dummy
|
|
||||||
copy(o[i+1:], o[i:])
|
|
||||||
o[i] = d.Value
|
|
||||||
object = o
|
|
||||||
}
|
|
||||||
|
|
||||||
if d.Delta != nil {
|
|
||||||
d.Delta.(PostDelta).PostApply(object)
|
|
||||||
}
|
|
||||||
|
|
||||||
return object
|
|
||||||
}
|
|
||||||
|
|
||||||
func (d *Moved) similarity() (similarity float64) {
|
|
||||||
similarity = 0.6 // as type and contens are same
|
|
||||||
ratio := float64(d.PrePosition().(Index)) / float64(d.PostPosition().(Index))
|
|
||||||
if ratio > 1 {
|
|
||||||
ratio = 1 / ratio
|
|
||||||
}
|
|
||||||
similarity += 0.4 * ratio
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
@ -1,428 +0,0 @@
|
||||||
// Copyright © 2016 Abcum Ltd
|
|
||||||
//
|
|
||||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
||||||
// you may not use this file except in compliance with the License.
|
|
||||||
// You may obtain a copy of the License at
|
|
||||||
//
|
|
||||||
// http://www.apache.org/licenses/LICENSE-2.0
|
|
||||||
//
|
|
||||||
// Unless required by applicable law or agreed to in writing, software
|
|
||||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
||||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
||||||
// See the License for the specific language governing permissions and
|
|
||||||
// limitations under the License.
|
|
||||||
|
|
||||||
// github.com/sergi/go-diff/diffmatchpatch
|
|
||||||
// github.com/yudai/gojsondiff
|
|
||||||
// github.com/yudai/golcs
|
|
||||||
|
|
||||||
package diff
|
|
||||||
|
|
||||||
/*type Diff struct{}
|
|
||||||
|
|
||||||
func (d *Diff) ToPACK() []byte {
|
|
||||||
return []byte("DIFF")
|
|
||||||
}*/
|
|
||||||
|
|
||||||
import (
|
|
||||||
"container/list"
|
|
||||||
"encoding/json"
|
|
||||||
"reflect"
|
|
||||||
"sort"
|
|
||||||
|
|
||||||
dmp "github.com/sergi/go-diff/diffmatchpatch"
|
|
||||||
"github.com/yudai/golcs"
|
|
||||||
)
|
|
||||||
|
|
||||||
// A Diff holds deltas generated by a Differ
|
|
||||||
type Diff interface {
|
|
||||||
// Deltas returns Deltas that describe differences between two JSON objects
|
|
||||||
Deltas() []Delta
|
|
||||||
// Modified returnes true if Diff has at least one Delta.
|
|
||||||
Modified() bool
|
|
||||||
}
|
|
||||||
|
|
||||||
type diff struct {
|
|
||||||
deltas []Delta
|
|
||||||
}
|
|
||||||
|
|
||||||
func (diff *diff) Deltas() []Delta {
|
|
||||||
return diff.deltas
|
|
||||||
}
|
|
||||||
|
|
||||||
func (diff *diff) Modified() bool {
|
|
||||||
return len(diff.deltas) > 0
|
|
||||||
}
|
|
||||||
|
|
||||||
// A Differ conmapres JSON objects and apply patches
|
|
||||||
type Differ struct {
|
|
||||||
textDiffMinimumLength int
|
|
||||||
}
|
|
||||||
|
|
||||||
// New returns new Differ with default configuration
|
|
||||||
func New() *Differ {
|
|
||||||
return &Differ{
|
|
||||||
textDiffMinimumLength: 10,
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// Compare compares two JSON strings as []bytes and return a Diff object.
|
|
||||||
func (differ *Differ) Compare(left []byte, right []byte) (Diff, error) {
|
|
||||||
var leftMap, rightMap map[string]interface{}
|
|
||||||
err := json.Unmarshal(left, &leftMap)
|
|
||||||
if err != nil {
|
|
||||||
return nil, err
|
|
||||||
}
|
|
||||||
|
|
||||||
err = json.Unmarshal(right, &rightMap)
|
|
||||||
if err != nil {
|
|
||||||
return nil, err
|
|
||||||
}
|
|
||||||
return differ.CompareObjects(leftMap, rightMap), nil
|
|
||||||
}
|
|
||||||
|
|
||||||
// CompareObjects compares two JSON object as map[string]interface{}
|
|
||||||
// and return a Diff object.
|
|
||||||
func (differ *Differ) CompareObjects(left map[string]interface{}, right map[string]interface{}) Diff {
|
|
||||||
deltas := differ.compareMaps(left, right)
|
|
||||||
return &diff{deltas: deltas}
|
|
||||||
}
|
|
||||||
|
|
||||||
func (differ *Differ) compareMaps(left map[string]interface{}, right map[string]interface{}) (deltas []Delta) {
|
|
||||||
deltas = make([]Delta, 0)
|
|
||||||
|
|
||||||
names := sortedKeys(left) // stabilize delta order
|
|
||||||
for _, name := range names {
|
|
||||||
if rightValue, ok := right[name]; ok {
|
|
||||||
same, delta := differ.compareValues(Name(name), left[name], rightValue)
|
|
||||||
if !same {
|
|
||||||
deltas = append(deltas, delta)
|
|
||||||
}
|
|
||||||
} else {
|
|
||||||
deltas = append(deltas, NewDeleted(Name(name), left[name]))
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
names = sortedKeys(right) // stabilize delta order
|
|
||||||
for _, name := range names {
|
|
||||||
if _, ok := left[name]; !ok {
|
|
||||||
deltas = append(deltas, NewAdded(Name(name), right[name]))
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
return deltas
|
|
||||||
}
|
|
||||||
|
|
||||||
// ApplyPatch applies a Diff to an JSON object. This method is destructive.
|
|
||||||
func (differ *Differ) ApplyPatch(json map[string]interface{}, patch Diff) {
|
|
||||||
applyDeltas(patch.Deltas(), json)
|
|
||||||
}
|
|
||||||
|
|
||||||
type maybe struct {
|
|
||||||
index int
|
|
||||||
lcsIndex int
|
|
||||||
item interface{}
|
|
||||||
}
|
|
||||||
|
|
||||||
func (differ *Differ) compareArrays(
|
|
||||||
left []interface{},
|
|
||||||
right []interface{},
|
|
||||||
) (deltas []Delta) {
|
|
||||||
deltas = make([]Delta, 0)
|
|
||||||
// LCS index pairs
|
|
||||||
lcsPairs := lcs.New(left, right).IndexPairs()
|
|
||||||
|
|
||||||
// list up items not in LCS, they are maybe deleted
|
|
||||||
maybeDeleted := list.New() // but maybe moved or modified
|
|
||||||
lcsI := 0
|
|
||||||
for i, leftValue := range left {
|
|
||||||
if lcsI < len(lcsPairs) && lcsPairs[lcsI].Left == i {
|
|
||||||
lcsI++
|
|
||||||
} else {
|
|
||||||
maybeDeleted.PushBack(maybe{index: i, lcsIndex: lcsI, item: leftValue})
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// list up items not in LCS, they are maybe Added
|
|
||||||
maybeAdded := list.New() // but maybe moved or modified
|
|
||||||
lcsI = 0
|
|
||||||
for i, rightValue := range right {
|
|
||||||
if lcsI < len(lcsPairs) && lcsPairs[lcsI].Right == i {
|
|
||||||
lcsI++
|
|
||||||
} else {
|
|
||||||
maybeAdded.PushBack(maybe{index: i, lcsIndex: lcsI, item: rightValue})
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// find moved items
|
|
||||||
var delNext *list.Element // for prefetch to remove item in iteration
|
|
||||||
for delCandidate := maybeDeleted.Front(); delCandidate != nil; delCandidate = delNext {
|
|
||||||
delCan := delCandidate.Value.(maybe)
|
|
||||||
delNext = delCandidate.Next()
|
|
||||||
|
|
||||||
for addCandidate := maybeAdded.Front(); addCandidate != nil; addCandidate = addCandidate.Next() {
|
|
||||||
addCan := addCandidate.Value.(maybe)
|
|
||||||
if reflect.DeepEqual(delCan.item, addCan.item) {
|
|
||||||
deltas = append(deltas, NewMoved(Index(delCan.index), Index(addCan.index), delCan.item, nil))
|
|
||||||
maybeAdded.Remove(addCandidate)
|
|
||||||
maybeDeleted.Remove(delCandidate)
|
|
||||||
break
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// find modified or add+del
|
|
||||||
prevIndexDel := 0
|
|
||||||
prevIndexAdd := 0
|
|
||||||
delElement := maybeDeleted.Front()
|
|
||||||
addElement := maybeAdded.Front()
|
|
||||||
for i := 0; i <= len(lcsPairs); i++ { // not "< len(lcsPairs)"
|
|
||||||
var lcsPair lcs.IndexPair
|
|
||||||
var delSize, addSize int
|
|
||||||
if i < len(lcsPairs) {
|
|
||||||
lcsPair = lcsPairs[i]
|
|
||||||
delSize = lcsPair.Left - prevIndexDel - 1
|
|
||||||
addSize = lcsPair.Right - prevIndexAdd - 1
|
|
||||||
prevIndexDel = lcsPair.Left
|
|
||||||
prevIndexAdd = lcsPair.Right
|
|
||||||
}
|
|
||||||
|
|
||||||
var delSlice []maybe
|
|
||||||
if delSize > 0 {
|
|
||||||
delSlice = make([]maybe, 0, delSize)
|
|
||||||
} else {
|
|
||||||
delSlice = make([]maybe, 0, maybeDeleted.Len())
|
|
||||||
}
|
|
||||||
for ; delElement != nil; delElement = delElement.Next() {
|
|
||||||
d := delElement.Value.(maybe)
|
|
||||||
if d.lcsIndex != i {
|
|
||||||
break
|
|
||||||
}
|
|
||||||
delSlice = append(delSlice, d)
|
|
||||||
}
|
|
||||||
|
|
||||||
var addSlice []maybe
|
|
||||||
if addSize > 0 {
|
|
||||||
addSlice = make([]maybe, 0, addSize)
|
|
||||||
} else {
|
|
||||||
addSlice = make([]maybe, 0, maybeAdded.Len())
|
|
||||||
}
|
|
||||||
for ; addElement != nil; addElement = addElement.Next() {
|
|
||||||
a := addElement.Value.(maybe)
|
|
||||||
if a.lcsIndex != i {
|
|
||||||
break
|
|
||||||
}
|
|
||||||
addSlice = append(addSlice, a)
|
|
||||||
}
|
|
||||||
|
|
||||||
if len(delSlice) > 0 && len(addSlice) > 0 {
|
|
||||||
var bestDeltas []Delta
|
|
||||||
bestDeltas, delSlice, addSlice = differ.maximizeSimilarities(delSlice, addSlice)
|
|
||||||
for _, delta := range bestDeltas {
|
|
||||||
deltas = append(deltas, delta)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
for _, del := range delSlice {
|
|
||||||
deltas = append(deltas, NewDeleted(Index(del.index), del.item))
|
|
||||||
}
|
|
||||||
for _, add := range addSlice {
|
|
||||||
deltas = append(deltas, NewAdded(Index(add.index), add.item))
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
return deltas
|
|
||||||
}
|
|
||||||
|
|
||||||
func (differ *Differ) compareValues(
|
|
||||||
position Position,
|
|
||||||
left interface{},
|
|
||||||
right interface{},
|
|
||||||
) (same bool, delta Delta) {
|
|
||||||
if reflect.TypeOf(left) != reflect.TypeOf(right) {
|
|
||||||
return false, NewModified(position, left, right)
|
|
||||||
}
|
|
||||||
|
|
||||||
switch left.(type) {
|
|
||||||
|
|
||||||
case map[string]interface{}:
|
|
||||||
l := left.(map[string]interface{})
|
|
||||||
childDeltas := differ.compareMaps(l, right.(map[string]interface{}))
|
|
||||||
if len(childDeltas) > 0 {
|
|
||||||
return false, NewObject(position, childDeltas)
|
|
||||||
}
|
|
||||||
|
|
||||||
case []interface{}:
|
|
||||||
l := left.([]interface{})
|
|
||||||
childDeltas := differ.compareArrays(l, right.([]interface{}))
|
|
||||||
|
|
||||||
if len(childDeltas) > 0 {
|
|
||||||
return false, NewArray(position, childDeltas)
|
|
||||||
}
|
|
||||||
|
|
||||||
default:
|
|
||||||
if !reflect.DeepEqual(left, right) {
|
|
||||||
|
|
||||||
if reflect.ValueOf(left).Kind() == reflect.String &&
|
|
||||||
reflect.ValueOf(right).Kind() == reflect.String &&
|
|
||||||
differ.textDiffMinimumLength <= len(left.(string)) {
|
|
||||||
|
|
||||||
textDiff := dmp.New()
|
|
||||||
patchs := textDiff.PatchMake(left.(string), right.(string))
|
|
||||||
return false, NewTextDiff(position, patchs, left, right)
|
|
||||||
|
|
||||||
} else {
|
|
||||||
return false, NewModified(position, left, right)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
return true, nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func applyDeltas(deltas []Delta, object interface{}) interface{} {
|
|
||||||
preDeltas := make(preDeltas, 0)
|
|
||||||
for _, delta := range deltas {
|
|
||||||
switch delta.(type) {
|
|
||||||
case PreDelta:
|
|
||||||
preDeltas = append(preDeltas, delta.(PreDelta))
|
|
||||||
}
|
|
||||||
}
|
|
||||||
sort.Sort(preDeltas)
|
|
||||||
for _, delta := range preDeltas {
|
|
||||||
object = delta.PreApply(object)
|
|
||||||
}
|
|
||||||
|
|
||||||
postDeltas := make(postDeltas, 0, len(deltas)-len(preDeltas))
|
|
||||||
for _, delta := range deltas {
|
|
||||||
switch delta.(type) {
|
|
||||||
case PostDelta:
|
|
||||||
postDeltas = append(postDeltas, delta.(PostDelta))
|
|
||||||
}
|
|
||||||
}
|
|
||||||
sort.Sort(postDeltas)
|
|
||||||
|
|
||||||
for _, delta := range postDeltas {
|
|
||||||
object = delta.PostApply(object)
|
|
||||||
}
|
|
||||||
|
|
||||||
return object
|
|
||||||
}
|
|
||||||
|
|
||||||
func (differ *Differ) maximizeSimilarities(left []maybe, right []maybe) (resultDeltas []Delta, freeLeft, freeRight []maybe) {
|
|
||||||
deltaTable := make([][]Delta, len(left))
|
|
||||||
for i := 0; i < len(left); i++ {
|
|
||||||
deltaTable[i] = make([]Delta, len(right))
|
|
||||||
}
|
|
||||||
for i, leftValue := range left {
|
|
||||||
for j, rightValue := range right {
|
|
||||||
_, delta := differ.compareValues(Index(rightValue.index), leftValue.item, rightValue.item)
|
|
||||||
deltaTable[i][j] = delta
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
sizeX := len(left) + 1 // margins for both sides
|
|
||||||
sizeY := len(right) + 1
|
|
||||||
|
|
||||||
// fill out with similarities
|
|
||||||
dpTable := make([][]float64, sizeX)
|
|
||||||
for i := 0; i < sizeX; i++ {
|
|
||||||
dpTable[i] = make([]float64, sizeY)
|
|
||||||
}
|
|
||||||
for x := sizeX - 2; x >= 0; x-- {
|
|
||||||
for y := sizeY - 2; y >= 0; y-- {
|
|
||||||
prevX := dpTable[x+1][y]
|
|
||||||
prevY := dpTable[x][y+1]
|
|
||||||
score := deltaTable[x][y].Similarity() + dpTable[x+1][y+1]
|
|
||||||
|
|
||||||
dpTable[x][y] = max(prevX, prevY, score)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
minLength := len(left)
|
|
||||||
if minLength > len(right) {
|
|
||||||
minLength = len(right)
|
|
||||||
}
|
|
||||||
maxInvalidLength := minLength - 1
|
|
||||||
|
|
||||||
freeLeft = make([]maybe, 0, len(left)-minLength)
|
|
||||||
freeRight = make([]maybe, 0, len(right)-minLength)
|
|
||||||
|
|
||||||
resultDeltas = make([]Delta, 0, minLength)
|
|
||||||
var x, y int
|
|
||||||
for x, y = 0, 0; x <= sizeX-2 && y <= sizeY-2; {
|
|
||||||
current := dpTable[x][y]
|
|
||||||
nextX := dpTable[x+1][y]
|
|
||||||
nextY := dpTable[x][y+1]
|
|
||||||
|
|
||||||
xValidLength := len(left) - maxInvalidLength + y
|
|
||||||
yValidLength := len(right) - maxInvalidLength + x
|
|
||||||
|
|
||||||
if x+1 < xValidLength && current == nextX {
|
|
||||||
freeLeft = append(freeLeft, left[x])
|
|
||||||
x++
|
|
||||||
} else if y+1 < yValidLength && current == nextY {
|
|
||||||
freeRight = append(freeRight, right[y])
|
|
||||||
y++
|
|
||||||
} else {
|
|
||||||
resultDeltas = append(resultDeltas, deltaTable[x][y])
|
|
||||||
x++
|
|
||||||
y++
|
|
||||||
}
|
|
||||||
}
|
|
||||||
for ; x < sizeX-1; x++ {
|
|
||||||
freeLeft = append(freeLeft, left[x-1])
|
|
||||||
}
|
|
||||||
for ; x < sizeY-1; y++ {
|
|
||||||
freeLeft = append(freeRight, left[y-1])
|
|
||||||
}
|
|
||||||
|
|
||||||
return resultDeltas, freeLeft, freeRight
|
|
||||||
}
|
|
||||||
|
|
||||||
func deltasSimilarity(deltas []Delta) (similarity float64) {
|
|
||||||
for _, delta := range deltas {
|
|
||||||
similarity += delta.Similarity()
|
|
||||||
}
|
|
||||||
similarity = similarity / float64(len(deltas))
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
func stringSimilarity(left, right string) (similarity float64) {
|
|
||||||
matchingLength := float64(
|
|
||||||
lcs.New(
|
|
||||||
stringToInterfaceSlice(left),
|
|
||||||
stringToInterfaceSlice(right),
|
|
||||||
).Length(),
|
|
||||||
)
|
|
||||||
similarity =
|
|
||||||
(matchingLength / float64(len(left))) * (matchingLength / float64(len(right)))
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
func stringToInterfaceSlice(str string) []interface{} {
|
|
||||||
s := make([]interface{}, len(str))
|
|
||||||
for i, v := range str {
|
|
||||||
s[i] = v
|
|
||||||
}
|
|
||||||
return s
|
|
||||||
}
|
|
||||||
|
|
||||||
func sortedKeys(m map[string]interface{}) (keys []string) {
|
|
||||||
keys = make([]string, 0, len(m))
|
|
||||||
for key, _ := range m {
|
|
||||||
keys = append(keys, key)
|
|
||||||
}
|
|
||||||
sort.Strings(keys)
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
func max(first float64, rest ...float64) (max float64) {
|
|
||||||
max = first
|
|
||||||
for _, value := range rest {
|
|
||||||
if max < value {
|
|
||||||
max = value
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return max
|
|
||||||
}
|
|
||||||
|
|
@ -1,131 +0,0 @@
|
||||||
package diff
|
|
||||||
|
|
||||||
import (
|
|
||||||
"encoding/json"
|
|
||||||
"errors"
|
|
||||||
dmp "github.com/sergi/go-diff/diffmatchpatch"
|
|
||||||
"io"
|
|
||||||
"strconv"
|
|
||||||
)
|
|
||||||
|
|
||||||
type Unmarshaller struct {
|
|
||||||
}
|
|
||||||
|
|
||||||
func NewUnmarshaller() *Unmarshaller {
|
|
||||||
return &Unmarshaller{}
|
|
||||||
}
|
|
||||||
|
|
||||||
func (um *Unmarshaller) UnmarshalBytes(diffBytes []byte) (Diff, error) {
|
|
||||||
var diffObj map[string]interface{}
|
|
||||||
json.Unmarshal(diffBytes, &diffObj)
|
|
||||||
return um.UnmarshalObject(diffObj)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (um *Unmarshaller) UnmarshalString(diffString string) (Diff, error) {
|
|
||||||
return um.UnmarshalBytes([]byte(diffString))
|
|
||||||
}
|
|
||||||
|
|
||||||
func (um *Unmarshaller) UnmarshalReader(diffReader io.Reader) (Diff, error) {
|
|
||||||
var diffBytes []byte
|
|
||||||
io.ReadFull(diffReader, diffBytes)
|
|
||||||
return um.UnmarshalBytes(diffBytes)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (um *Unmarshaller) UnmarshalObject(diffObj map[string]interface{}) (Diff, error) {
|
|
||||||
result, err := process(Name(""), diffObj)
|
|
||||||
if err != nil {
|
|
||||||
return nil, err
|
|
||||||
}
|
|
||||||
return &diff{deltas: result.(*Object).Deltas}, nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func process(position Position, object interface{}) (Delta, error) {
|
|
||||||
var delta Delta
|
|
||||||
switch object.(type) {
|
|
||||||
case map[string]interface{}:
|
|
||||||
o := object.(map[string]interface{})
|
|
||||||
if isArray, typed := o["_t"]; typed && isArray == "a" {
|
|
||||||
deltas := make([]Delta, 0, len(o))
|
|
||||||
for name, value := range o {
|
|
||||||
if name == "_t" {
|
|
||||||
continue
|
|
||||||
}
|
|
||||||
|
|
||||||
normalizedName := name
|
|
||||||
if normalizedName[0] == '_' {
|
|
||||||
normalizedName = name[1:]
|
|
||||||
}
|
|
||||||
index, err := strconv.Atoi(normalizedName)
|
|
||||||
if err != nil {
|
|
||||||
return nil, err
|
|
||||||
}
|
|
||||||
|
|
||||||
childDelta, err := process(Index(index), value)
|
|
||||||
if err != nil {
|
|
||||||
return nil, err
|
|
||||||
}
|
|
||||||
|
|
||||||
deltas = append(deltas, childDelta)
|
|
||||||
}
|
|
||||||
|
|
||||||
for _, d := range deltas {
|
|
||||||
switch d.(type) {
|
|
||||||
case *Moved:
|
|
||||||
moved := d.(*Moved)
|
|
||||||
|
|
||||||
var dd interface{}
|
|
||||||
var i int
|
|
||||||
for i, dd = range deltas {
|
|
||||||
switch dd.(type) {
|
|
||||||
case *Moved:
|
|
||||||
case PostDelta:
|
|
||||||
pd := dd.(PostDelta)
|
|
||||||
if moved.PostPosition() == pd.PostPosition() {
|
|
||||||
moved.Delta = pd
|
|
||||||
deltas = append(deltas[:i], deltas[i+1:]...)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
delta = NewArray(position, deltas)
|
|
||||||
} else {
|
|
||||||
deltas := make([]Delta, 0, len(o))
|
|
||||||
for name, value := range o {
|
|
||||||
childDelta, err := process(Name(name), value)
|
|
||||||
if err != nil {
|
|
||||||
return nil, err
|
|
||||||
}
|
|
||||||
deltas = append(deltas, childDelta)
|
|
||||||
}
|
|
||||||
delta = NewObject(position, deltas)
|
|
||||||
}
|
|
||||||
case []interface{}:
|
|
||||||
o := object.([]interface{})
|
|
||||||
switch len(o) {
|
|
||||||
case 1:
|
|
||||||
delta = NewAdded(position, o[0])
|
|
||||||
case 2:
|
|
||||||
delta = NewModified(position, o[0], o[1])
|
|
||||||
case 3:
|
|
||||||
switch o[2] {
|
|
||||||
case float64(0):
|
|
||||||
delta = NewDeleted(position, o[0])
|
|
||||||
case float64(2):
|
|
||||||
dmp := dmp.New()
|
|
||||||
patches, err := dmp.PatchFromText(o[0].(string))
|
|
||||||
if err != nil {
|
|
||||||
return nil, err
|
|
||||||
}
|
|
||||||
delta = NewTextDiff(position, patches, nil, nil)
|
|
||||||
case float64(3):
|
|
||||||
delta = NewMoved(position, Index(int(o[1].(float64))), nil, nil)
|
|
||||||
default:
|
|
||||||
return nil, errors.New("Unknown delta type")
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
return delta, nil
|
|
||||||
}
|
|
||||||
|
|
@ -1,297 +0,0 @@
|
||||||
package form
|
|
||||||
|
|
||||||
import (
|
|
||||||
"errors"
|
|
||||||
"fmt"
|
|
||||||
"sort"
|
|
||||||
|
|
||||||
diff "github.com/abcum/surreal/util/diff"
|
|
||||||
)
|
|
||||||
|
|
||||||
func NewAsciiFormatter(left map[string]interface{}) *AsciiFormatter {
|
|
||||||
return &AsciiFormatter{
|
|
||||||
left: left,
|
|
||||||
ShowArrayIndex: false,
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
type AsciiFormatter struct {
|
|
||||||
left map[string]interface{}
|
|
||||||
ShowArrayIndex bool
|
|
||||||
buffer string
|
|
||||||
path []string
|
|
||||||
size []int
|
|
||||||
inArray []bool
|
|
||||||
}
|
|
||||||
|
|
||||||
func (f *AsciiFormatter) Format(diff diff.Diff) (result string, err error) {
|
|
||||||
f.buffer = ""
|
|
||||||
f.path = []string{}
|
|
||||||
f.size = []int{}
|
|
||||||
f.inArray = []bool{}
|
|
||||||
|
|
||||||
f.printIndent(AsciiSame)
|
|
||||||
f.println("{")
|
|
||||||
f.push("ROOT", len(f.left), false)
|
|
||||||
f.processObject(f.left, diff.Deltas())
|
|
||||||
f.pop()
|
|
||||||
f.printIndent(AsciiSame)
|
|
||||||
f.println("}")
|
|
||||||
|
|
||||||
return f.buffer, nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func (f *AsciiFormatter) processArray(array []interface{}, deltas []diff.Delta) error {
|
|
||||||
patchedIndex := 0
|
|
||||||
for index, value := range array {
|
|
||||||
f.processItem(value, deltas, diff.Index(index))
|
|
||||||
patchedIndex++
|
|
||||||
}
|
|
||||||
|
|
||||||
// additional Added
|
|
||||||
for _, delta := range deltas {
|
|
||||||
switch delta.(type) {
|
|
||||||
case *diff.Added:
|
|
||||||
d := delta.(*diff.Added)
|
|
||||||
// skip items already processed
|
|
||||||
if int(d.Position.(diff.Index)) < len(array) {
|
|
||||||
continue
|
|
||||||
}
|
|
||||||
f.printRecursive(d.Position.String(), d.Value, AsciiAdded)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func (f *AsciiFormatter) processObject(object map[string]interface{}, deltas []diff.Delta) error {
|
|
||||||
names := sortedKeys(object)
|
|
||||||
for _, name := range names {
|
|
||||||
value := object[name]
|
|
||||||
f.processItem(value, deltas, diff.Name(name))
|
|
||||||
}
|
|
||||||
|
|
||||||
// Added
|
|
||||||
for _, delta := range deltas {
|
|
||||||
switch delta.(type) {
|
|
||||||
case *diff.Added:
|
|
||||||
d := delta.(*diff.Added)
|
|
||||||
f.printRecursive(d.Position.String(), d.Value, AsciiAdded)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func (f *AsciiFormatter) processItem(value interface{}, deltas []diff.Delta, position diff.Position) error {
|
|
||||||
matchedDeltas := f.searchDeltas(deltas, position)
|
|
||||||
positionStr := position.String()
|
|
||||||
if len(matchedDeltas) > 0 {
|
|
||||||
for _, matchedDelta := range matchedDeltas {
|
|
||||||
|
|
||||||
switch matchedDelta.(type) {
|
|
||||||
case *diff.Object:
|
|
||||||
d := matchedDelta.(*diff.Object)
|
|
||||||
switch value.(type) {
|
|
||||||
case map[string]interface{}:
|
|
||||||
//ok
|
|
||||||
default:
|
|
||||||
return errors.New("Type mismatch")
|
|
||||||
}
|
|
||||||
o := value.(map[string]interface{})
|
|
||||||
|
|
||||||
f.printKeyWithIndent(positionStr, AsciiSame)
|
|
||||||
f.println("{")
|
|
||||||
f.push(positionStr, len(o), false)
|
|
||||||
f.processObject(o, d.Deltas)
|
|
||||||
f.pop()
|
|
||||||
f.printIndent(AsciiSame)
|
|
||||||
f.print("}")
|
|
||||||
f.printComma()
|
|
||||||
|
|
||||||
case *diff.Array:
|
|
||||||
d := matchedDelta.(*diff.Array)
|
|
||||||
switch value.(type) {
|
|
||||||
case []interface{}:
|
|
||||||
//ok
|
|
||||||
default:
|
|
||||||
return errors.New("Type mismatch")
|
|
||||||
}
|
|
||||||
a := value.([]interface{})
|
|
||||||
|
|
||||||
f.printKeyWithIndent(positionStr, AsciiSame)
|
|
||||||
f.println("[")
|
|
||||||
f.push(positionStr, len(a), true)
|
|
||||||
f.processArray(a, d.Deltas)
|
|
||||||
f.pop()
|
|
||||||
f.printIndent(AsciiSame)
|
|
||||||
f.print("]")
|
|
||||||
f.printComma()
|
|
||||||
|
|
||||||
case *diff.Added:
|
|
||||||
d := matchedDelta.(*diff.Added)
|
|
||||||
f.printRecursive(positionStr, d.Value, AsciiAdded)
|
|
||||||
f.size[len(f.size)-1]++
|
|
||||||
|
|
||||||
case *diff.Modified:
|
|
||||||
d := matchedDelta.(*diff.Modified)
|
|
||||||
savedSize := f.size[len(f.size)-1]
|
|
||||||
f.printRecursive(positionStr, d.OldValue, AsciiDeleted)
|
|
||||||
f.size[len(f.size)-1] = savedSize
|
|
||||||
f.printRecursive(positionStr, d.NewValue, AsciiAdded)
|
|
||||||
|
|
||||||
case *diff.TextDiff:
|
|
||||||
savedSize := f.size[len(f.size)-1]
|
|
||||||
d := matchedDelta.(*diff.TextDiff)
|
|
||||||
f.printRecursive(positionStr, d.OldValue, AsciiDeleted)
|
|
||||||
f.size[len(f.size)-1] = savedSize
|
|
||||||
f.printRecursive(positionStr, d.NewValue, AsciiAdded)
|
|
||||||
|
|
||||||
case *diff.Deleted:
|
|
||||||
d := matchedDelta.(*diff.Deleted)
|
|
||||||
f.printRecursive(positionStr, d.Value, AsciiDeleted)
|
|
||||||
|
|
||||||
default:
|
|
||||||
return errors.New("Unknown Delta type detected")
|
|
||||||
}
|
|
||||||
|
|
||||||
}
|
|
||||||
} else {
|
|
||||||
f.printRecursive(positionStr, value, AsciiSame)
|
|
||||||
}
|
|
||||||
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func (f *AsciiFormatter) searchDeltas(deltas []diff.Delta, postion diff.Position) (results []diff.Delta) {
|
|
||||||
results = make([]diff.Delta, 0)
|
|
||||||
for _, delta := range deltas {
|
|
||||||
switch delta.(type) {
|
|
||||||
case diff.PostDelta:
|
|
||||||
if delta.(diff.PostDelta).PostPosition() == postion {
|
|
||||||
results = append(results, delta)
|
|
||||||
}
|
|
||||||
case diff.PreDelta:
|
|
||||||
if delta.(diff.PreDelta).PrePosition() == postion {
|
|
||||||
results = append(results, delta)
|
|
||||||
}
|
|
||||||
default:
|
|
||||||
panic("heh")
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
const (
|
|
||||||
AsciiSame = " "
|
|
||||||
AsciiAdded = "+"
|
|
||||||
AsciiDeleted = "-"
|
|
||||||
)
|
|
||||||
|
|
||||||
func (f *AsciiFormatter) push(name string, size int, array bool) {
|
|
||||||
f.path = append(f.path, name)
|
|
||||||
f.size = append(f.size, size)
|
|
||||||
f.inArray = append(f.inArray, array)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (f *AsciiFormatter) pop() {
|
|
||||||
f.path = f.path[0 : len(f.path)-1]
|
|
||||||
f.size = f.size[0 : len(f.size)-1]
|
|
||||||
f.inArray = f.inArray[0 : len(f.inArray)-1]
|
|
||||||
}
|
|
||||||
|
|
||||||
func (f *AsciiFormatter) printIndent(marker string) {
|
|
||||||
f.print(marker)
|
|
||||||
for n := 0; n < len(f.path); n++ {
|
|
||||||
f.print(" ")
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func (f *AsciiFormatter) printKeyWithIndent(name string, marker string) {
|
|
||||||
f.printIndent(marker)
|
|
||||||
if !f.inArray[len(f.inArray)-1] {
|
|
||||||
f.printf(`"%s": `, name)
|
|
||||||
} else if f.ShowArrayIndex {
|
|
||||||
f.printf(`%s: `, name)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func (f *AsciiFormatter) printComma() {
|
|
||||||
f.size[len(f.size)-1]--
|
|
||||||
if f.size[len(f.size)-1] > 0 {
|
|
||||||
f.println(",")
|
|
||||||
} else {
|
|
||||||
f.println()
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func (f *AsciiFormatter) printValue(value interface{}) {
|
|
||||||
switch value.(type) {
|
|
||||||
case string:
|
|
||||||
f.buffer += fmt.Sprintf(`"%s"`, value)
|
|
||||||
default:
|
|
||||||
f.buffer += fmt.Sprintf(`%#v`, value)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func (f *AsciiFormatter) print(a ...interface{}) {
|
|
||||||
f.buffer += fmt.Sprint(a...)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (f *AsciiFormatter) printf(format string, a ...interface{}) {
|
|
||||||
f.buffer += fmt.Sprintf(format, a...)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (f *AsciiFormatter) println(a ...interface{}) {
|
|
||||||
f.buffer += fmt.Sprintln(a...)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (f *AsciiFormatter) printRecursive(name string, value interface{}, marker string) {
|
|
||||||
switch value.(type) {
|
|
||||||
case map[string]interface{}:
|
|
||||||
f.printKeyWithIndent(name, marker)
|
|
||||||
f.println("{")
|
|
||||||
|
|
||||||
m := value.(map[string]interface{})
|
|
||||||
size := len(m)
|
|
||||||
f.push(name, size, false)
|
|
||||||
|
|
||||||
keys := sortedKeys(m)
|
|
||||||
for _, key := range keys {
|
|
||||||
f.printRecursive(key, m[key], marker)
|
|
||||||
}
|
|
||||||
f.pop()
|
|
||||||
|
|
||||||
f.printIndent(marker)
|
|
||||||
f.print("}")
|
|
||||||
f.printComma()
|
|
||||||
case []interface{}:
|
|
||||||
f.printKeyWithIndent(name, marker)
|
|
||||||
f.println("[")
|
|
||||||
|
|
||||||
s := value.([]interface{})
|
|
||||||
size := len(s)
|
|
||||||
f.push("", size, true)
|
|
||||||
for _, item := range s {
|
|
||||||
f.printRecursive("", item, marker)
|
|
||||||
}
|
|
||||||
f.pop()
|
|
||||||
|
|
||||||
f.printIndent(marker)
|
|
||||||
f.print("]")
|
|
||||||
f.printComma()
|
|
||||||
default:
|
|
||||||
f.printKeyWithIndent(name, marker)
|
|
||||||
f.printValue(value)
|
|
||||||
f.printComma()
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func sortedKeys(m map[string]interface{}) (keys []string) {
|
|
||||||
keys = make([]string, 0, len(m))
|
|
||||||
for key, _ := range m {
|
|
||||||
keys = append(keys, key)
|
|
||||||
}
|
|
||||||
sort.Strings(keys)
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
@ -1,124 +0,0 @@
|
||||||
package form
|
|
||||||
|
|
||||||
import (
|
|
||||||
"encoding/json"
|
|
||||||
"errors"
|
|
||||||
"fmt"
|
|
||||||
|
|
||||||
diff "github.com/abcum/surreal/util/diff"
|
|
||||||
)
|
|
||||||
|
|
||||||
const (
|
|
||||||
DeltaDelete = 0
|
|
||||||
DeltaTextDiff = 2
|
|
||||||
DeltaMove = 3
|
|
||||||
)
|
|
||||||
|
|
||||||
func NewDeltaFormatter() *DeltaFormatter {
|
|
||||||
return &DeltaFormatter{
|
|
||||||
PrintIndent: true,
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
type DeltaFormatter struct {
|
|
||||||
PrintIndent bool
|
|
||||||
}
|
|
||||||
|
|
||||||
func (f *DeltaFormatter) Format(diff diff.Diff) (result string, err error) {
|
|
||||||
jsonObject, err := f.formatObject(diff.Deltas())
|
|
||||||
if err != nil {
|
|
||||||
return "", err
|
|
||||||
}
|
|
||||||
var resultBytes []byte
|
|
||||||
if f.PrintIndent {
|
|
||||||
resultBytes, err = json.MarshalIndent(jsonObject, "", " ")
|
|
||||||
} else {
|
|
||||||
resultBytes, err = json.Marshal(jsonObject)
|
|
||||||
}
|
|
||||||
if err != nil {
|
|
||||||
return "", err
|
|
||||||
}
|
|
||||||
|
|
||||||
return string(resultBytes), nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func (f *DeltaFormatter) FormatAsJson(diff diff.Diff) (json map[string]interface{}, err error) {
|
|
||||||
return f.formatObject(diff.Deltas())
|
|
||||||
}
|
|
||||||
|
|
||||||
func (f *DeltaFormatter) formatObject(deltas []diff.Delta) (deltaJson map[string]interface{}, err error) {
|
|
||||||
deltaJson = map[string]interface{}{}
|
|
||||||
for _, delta := range deltas {
|
|
||||||
switch delta.(type) {
|
|
||||||
case *diff.Object:
|
|
||||||
d := delta.(*diff.Object)
|
|
||||||
deltaJson[d.Position.String()], err = f.formatObject(d.Deltas)
|
|
||||||
if err != nil {
|
|
||||||
return nil, err
|
|
||||||
}
|
|
||||||
case *diff.Array:
|
|
||||||
d := delta.(*diff.Array)
|
|
||||||
deltaJson[d.Position.String()], err = f.formatArray(d.Deltas)
|
|
||||||
if err != nil {
|
|
||||||
return nil, err
|
|
||||||
}
|
|
||||||
case *diff.Added:
|
|
||||||
d := delta.(*diff.Added)
|
|
||||||
deltaJson[d.PostPosition().String()] = []interface{}{d.Value}
|
|
||||||
case *diff.Modified:
|
|
||||||
d := delta.(*diff.Modified)
|
|
||||||
deltaJson[d.PostPosition().String()] = []interface{}{d.OldValue, d.NewValue}
|
|
||||||
case *diff.TextDiff:
|
|
||||||
d := delta.(*diff.TextDiff)
|
|
||||||
deltaJson[d.PostPosition().String()] = []interface{}{d.DiffString(), 0, DeltaTextDiff}
|
|
||||||
case *diff.Deleted:
|
|
||||||
d := delta.(*diff.Deleted)
|
|
||||||
deltaJson[d.PrePosition().String()] = []interface{}{d.Value, 0, DeltaDelete}
|
|
||||||
case *diff.Moved:
|
|
||||||
return nil, errors.New("Delta type 'Move' is not supported in objects")
|
|
||||||
default:
|
|
||||||
return nil, errors.New(fmt.Sprintf("Unknown Delta type detected: %#v", delta))
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
func (f *DeltaFormatter) formatArray(deltas []diff.Delta) (deltaJson map[string]interface{}, err error) {
|
|
||||||
deltaJson = map[string]interface{}{
|
|
||||||
"_t": "a",
|
|
||||||
}
|
|
||||||
for _, delta := range deltas {
|
|
||||||
switch delta.(type) {
|
|
||||||
case *diff.Object:
|
|
||||||
d := delta.(*diff.Object)
|
|
||||||
deltaJson[d.Position.String()], err = f.formatObject(d.Deltas)
|
|
||||||
if err != nil {
|
|
||||||
return nil, err
|
|
||||||
}
|
|
||||||
case *diff.Array:
|
|
||||||
d := delta.(*diff.Array)
|
|
||||||
deltaJson[d.Position.String()], err = f.formatArray(d.Deltas)
|
|
||||||
if err != nil {
|
|
||||||
return nil, err
|
|
||||||
}
|
|
||||||
case *diff.Added:
|
|
||||||
d := delta.(*diff.Added)
|
|
||||||
deltaJson[d.PostPosition().String()] = []interface{}{d.Value}
|
|
||||||
case *diff.Modified:
|
|
||||||
d := delta.(*diff.Modified)
|
|
||||||
deltaJson[d.PostPosition().String()] = []interface{}{d.OldValue, d.NewValue}
|
|
||||||
case *diff.TextDiff:
|
|
||||||
d := delta.(*diff.TextDiff)
|
|
||||||
deltaJson[d.PostPosition().String()] = []interface{}{d.DiffString(), 0, DeltaTextDiff}
|
|
||||||
case *diff.Deleted:
|
|
||||||
d := delta.(*diff.Deleted)
|
|
||||||
deltaJson["_"+d.PrePosition().String()] = []interface{}{d.Value, 0, DeltaDelete}
|
|
||||||
case *diff.Moved:
|
|
||||||
d := delta.(*diff.Moved)
|
|
||||||
deltaJson["_"+d.PrePosition().String()] = []interface{}{"", d.PostPosition(), DeltaMove}
|
|
||||||
default:
|
|
||||||
return nil, errors.New(fmt.Sprintf("Unknown Delta type detected: %#v", delta))
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return
|
|
||||||
}
|
|
||||||
Loading…
Reference in a new issue