Пример #1
2
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)
}
Пример #2
0
// 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
}
Пример #3
0
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
}
Пример #4
0
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()
	}
}
Пример #5
0
// 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)
}
Пример #6
0
// 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)
}
Пример #7
0
// 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
}
Пример #8
0
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)
}
Пример #9
0
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
}
Пример #10
0
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()
	}
}
Пример #11
0
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
}
Пример #12
0
// 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
}
Пример #13
0
// 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)
}
Пример #14
0
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)
}
Пример #15
0
// 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)
}
Пример #16
0
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
}