func DumpDiff(expectedObj, actualObj interface{}) {
expected := pretty.Sprintf("%# v\n", expectedObj)
actual := pretty.Sprintf("%# v\n", actualObj)
diff := difflib.UnifiedDiff{
A: difflib.SplitLines(expected),
B: difflib.SplitLines(actual),
FromFile: "expected",
ToFile: "actual",
Context: 3,
}
text, _ := difflib.GetUnifiedDiffString(diff)
fmt.Print(text)
}
// diff returns a diff of both values as long as both are of the same type and
// are a struct, map, slice or array. Otherwise it returns an empty string.
func diff(expected interface{}, actual interface{}) string {
if expected == nil || actual == nil {
return ""
}
et, ek := typeAndKind(expected)
at, _ := typeAndKind(actual)
if et != at {
return ""
}
if ek != reflect.Struct && ek != reflect.Map && ek != reflect.Slice && ek != reflect.Array {
return ""
}
e := spew.Sdump(expected)
a := spew.Sdump(actual)
diff, _ := difflib.GetUnifiedDiffString(difflib.UnifiedDiff{
A: difflib.SplitLines(e),
B: difflib.SplitLines(a),
FromFile: "Expected",
FromDate: "",
ToFile: "Actual",
ToDate: "",
Context: 1,
})
return "\n\nDiff:\n" + diff
}
func NewDiffInfo(target string) (*DiffInfo, error) {
from := path.Join(rsyncFrom, target)
to := path.Join(rsyncTo, target)
fromExist := isFileExist(from)
fromIsDiffTarget := isDiffTarget(from)
toExist := isFileExist(to)
toIsDiffTarget := isDiffTarget(to)
fromLines := ""
if fromExist && fromIsDiffTarget {
bytes, err := ioutil.ReadFile(from)
if err != nil {
return nil, err
}
fromLines = string(bytes)
}
toLines := ""
if toExist && toIsDiffTarget {
bytes, err := ioutil.ReadFile(to)
if err != nil {
return nil, err
}
toLines = string(bytes)
}
info := &DiffInfo{}
info.A = difflib.SplitLines(toLines)
info.B = difflib.SplitLines(fromLines)
info.FromFile = from
info.ToFile = to
return info, nil
}
func TestOptionMerge(t *testing.T) {
InitLogging()
logging.SetLevel(logging.DEBUG, "")
cli := &TestCli{*New("test")}
cli.SetDefaults(map[string]interface{}{
"a": 1,
"b": 2,
"hash": map[string]interface{}{
"a": 1,
"b": 2,
"hoh": map[string]interface{}{
"a": 1,
"b": 2,
},
"hol": map[string]interface{}{
"a": []interface{}{1, 2},
"b": []interface{}{3, 4},
},
},
"list": []interface{}{
"a",
"b",
},
"lol": []interface{}{
[]interface{}{"a", "b", "c"},
[]interface{}{"d", "e", "f"},
},
})
os.Args = []string{os.Args[0]}
ProcessAllOptions(cli)
log.Debugf("processed: %#v", cli.GetOptions())
options := cli.GetOptions()
if !reflect.DeepEqual(options, TestOptionMergeExpected) {
log.Debugf("processed: %#v", options)
got, err := json.MarshalIndent(options, "", " ")
if err != nil {
log.Errorf("Failed to marshal json: %s", err)
}
log.Debugf("got: %#v", string(got))
log.Debugf("processed: %#v", options)
got, err = json.MarshalIndent(options, "", " ")
log.Debugf("got: %#v", string(got))
expected, _ := json.MarshalIndent(TestOptionMergeExpected, "", " ")
diff := difflib.UnifiedDiff{
A: difflib.SplitLines(string(expected)),
B: difflib.SplitLines(string(got)),
FromFile: "Expected",
ToFile: "Got",
Context: 3,
}
result, _ := difflib.GetUnifiedDiffString(diff)
log.Errorf("Diff:\n%s", result)
t.Fail()
}
}
// Unified compares two strings and output the differences.
func Unified(a, b string) (string, error) {
diff := difflib.UnifiedDiff{
A: difflib.SplitLines(a),
B: difflib.SplitLines(b),
FromFile: "Original",
ToFile: "Current",
Context: 1,
}
return difflib.GetUnifiedDiffString(diff)
}
// RawDiff returns a contextual diff of the running rule configuration
// against the provided configuration. This contextual diff library
// does not guarantee that the generated unified diff can be applied
// so this is only used for human consumption and verifying that the diff
// has not change since an edit request was issued
func (c *Conf) RawDiff(rawConf string) (string, error) {
diff := difflib.UnifiedDiff{
A: difflib.SplitLines(c.RawText),
B: difflib.SplitLines(rawConf),
FromFile: c.Name,
ToFile: c.Name,
Context: 3,
}
return difflib.GetUnifiedDiffString(diff)
}
// Diff diff diff
func Diff(want, have interface{}) string {
text, _ := difflib.GetUnifiedDiffString(difflib.UnifiedDiff{
A: difflib.SplitLines(spew.Sdump(want)),
B: difflib.SplitLines(spew.Sdump(have)),
FromFile: "want",
ToFile: "have",
Context: 3,
})
return "\n" + text
}
func GenerateDiff(prevName, prevStr, currName, currStr string) (string, error) {
diff := difflib.UnifiedDiff{
A: difflib.SplitLines(prevStr),
B: difflib.SplitLines(currStr),
FromFile: prevName,
ToFile: currName,
Context: 0,
}
return difflib.GetUnifiedDiffString(diff)
}
func godiff(a, b string) string {
diff := difflib.UnifiedDiff{
A: difflib.SplitLines(a),
B: difflib.SplitLines(b),
FromFile: "File A",
ToFile: "File B",
Context: 3,
}
text, err := difflib.GetUnifiedDiffString(diff)
if err != nil {
log.Fatal(err)
}
return text
}
func TestOptionMergeSubdir(t *testing.T) {
os.Chdir("subdir")
InitLogging()
logging.SetLevel(logging.DEBUG, "")
cli := &TestCli{*New("test")}
cli.SetDefaults(map[string]interface{}{
"a": 1,
"b": 2,
"hash": map[string]interface{}{
"a": 1,
"b": 2,
"hoh": map[string]interface{}{
"a": 1,
"b": 2,
},
"hol": map[string]interface{}{
"a": []interface{}{1, 2},
"b": []interface{}{3, 4},
},
},
"list": []interface{}{
"a",
"b",
},
"lol": []interface{}{
[]interface{}{"a", "b", "c"},
[]interface{}{"d", "e", "f"},
},
})
ProcessAllOptions(cli)
if !reflect.DeepEqual(cli.GetOptions(), TestOptionMergeSubdirExpected) {
got, _ := json.MarshalIndent(cli.GetOptions(), "", " ")
expected, _ := json.MarshalIndent(TestOptionMergeSubdirExpected, "", " ")
diff := difflib.UnifiedDiff{
A: difflib.SplitLines(string(expected)),
B: difflib.SplitLines(string(got)),
FromFile: "Expected",
ToFile: "Got",
Context: 3,
}
result, _ := difflib.GetUnifiedDiffString(diff)
log.Errorf("Diff:\n%s", result)
t.Fail()
}
}
func formatFile(filepath string, runWrite, runDiff bool) error {
format, _ := fzp.GetFormat(filepath)
if format != fzp.FormatFzp {
return errors.New("at the moment only fzp format supported")
}
fzpFile, fzpBytes, err := fzp.ReadFzp(filepath)
if err != nil {
fmt.Println(err)
return err
}
formattedXML, err := fzpFile.ToXML()
if err != nil {
fmt.Println(err)
return err
}
if runWrite {
err := ioutil.WriteFile(filepath, formattedXML, 0755)
if err != nil {
fmt.Println("Error", err)
os.Exit(127)
}
return nil
}
// diff
if runDiff {
diff := difflib.ContextDiff{
A: difflib.SplitLines(string(fzpBytes)),
B: difflib.SplitLines(string(formattedXML)),
FromFile: filepath,
ToFile: "Current",
Context: 3,
Eol: "\n",
}
result, _ := difflib.GetContextDiffString(diff)
fmt.Printf(strings.Replace(result, "\t", " ", -1))
return nil
}
fmt.Println(string(formattedXML))
return nil
}
// Diff returns the difference between the textual representation of two deployments
func (d *Deployment) Diff(other *Deployment) string {
if other == nil {
return "other was nil"
}
diff := difflib.UnifiedDiff{
A: difflib.SplitLines(d.String()),
B: difflib.SplitLines(other.String()),
FromFile: "ThisDeployment",
ToFile: "OtherDeployment",
}
out, err := difflib.GetUnifiedDiffString(diff)
if err != nil {
panic(err)
}
return out
}
// Diff consumes the entire reader streams into memory before generating a diff
// which then gets filled into the buffer. This implementation stores and
// manipulates all three values in memory.
func (diff *differ) Diff(out io.Writer, a io.ReadSeeker, b io.ReadSeeker) error {
var src, dst []byte
var err error
if src, err = ioutil.ReadAll(a); err != nil {
return err
}
if dst, err = ioutil.ReadAll(b); err != nil {
return err
}
d := difflib.UnifiedDiff{
A: difflib.SplitLines(string(src)),
B: difflib.SplitLines(string(dst)),
Context: 3,
}
return difflib.WriteUnifiedDiff(out, d)
}
func diffDeployment(currRaw, newRaw string) (string, error) {
curr, err := prettifyJSON(currRaw)
if err != nil {
return "", err
}
new, err := prettifyJSON(newRaw)
if err != nil {
return "", err
}
diff := difflib.UnifiedDiff{
A: difflib.SplitLines(curr),
B: difflib.SplitLines(new),
FromFile: "Current",
ToFile: "Proposed",
Context: 3,
}
return difflib.GetUnifiedDiffString(diff)
}
// diffStr returns a unified diff string of two Godeps.
func diffStr(a, b *Godeps) (string, error) {
var ab, bb bytes.Buffer
_, err := a.WriteTo(&ab)
if err != nil {
log.Fatalln(err)
}
_, err = b.WriteTo(&bb)
if err != nil {
log.Fatalln(err)
}
diff := difflib.UnifiedDiff{
A: difflib.SplitLines(ab.String()),
B: difflib.SplitLines(bb.String()),
FromFile: "Godeps",
ToFile: "$GOPATH",
Context: 10,
}
return difflib.GetUnifiedDiffString(diff)
}
func (t *ZkLiveTree) diffNode(node *ZkNode) error {
log.Printf("diff node @ `%s`", node.Path)
diff := difflib.UnifiedDiff{
FromFile: "a" + node.Path,
ToFile: "b" + node.Path,
Context: 3,
}
if data, err := t.client.GetData().ForPath(node.Path); err == nil {
diff.A = difflib.SplitLines(node.Value)
diff.B = difflib.SplitLines(string(data))
} else if err == curator.ErrNoNode {
diff.A = difflib.SplitLines(node.Value)
} else {
return err
}
if err := difflib.WriteUnifiedDiff(os.Stdout, diff); err != nil {
return err
}
return nil
}