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 UnifiedOutput(diffTargets []string) (int, error) {
tmp, err := ioutil.TempFile(os.TempDir(), "rsyncdiff")
if err != nil {
return 1, err
}
defer os.Remove(tmp.Name())
for _, target := range diffTargets {
diffInfo, err := NewDiffInfo(target)
if err != nil {
return 1, err
}
diff := difflib.UnifiedDiff{
A: diffInfo.A,
B: diffInfo.B,
FromFile: diffInfo.FromFile,
ToFile: diffInfo.ToFile,
}
result, err := difflib.GetUnifiedDiffString(diff)
if err != nil {
return 1, err
}
_, err = tmp.WriteString(result)
if err != nil {
return 1, err
}
tmp.Sync()
}
cmd := &Command{}
cmd.Command = "cat"
cmd.Options = []string{tmp.Name()}
return cmd.Run()
}
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()
}
}
// 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
}
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)
}