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 }