package diff

import "golang.org/x/tools/internal/diff"

Package diff computes differences between text files or strings.

Index ¶

• Constants
• func Apply(src string, edits []Edit) (string, error)
• func ApplyBytes(src []byte, edits []Edit) ([]byte, error)
• func SortEdits(edits []Edit)
• func ToUnified(oldLabel, newLabel, content string, edits []Edit, contextLines int) (string, error)
• func Unified(oldLabel, newLabel, old, new string) string
• type Edit
• func Bytes(before, after []byte) []Edit
• func Merge(x, y []Edit) ([]Edit, bool)
• func Strings(before, after string) []Edit
• func (e Edit) String() string

Constants ¶

const DefaultContextLines = 3

DefaultContextLines is the number of unchanged lines of surrounding context displayed by Unified. Use ToUnified to specify a different value.

Functions ¶

func Apply ¶

func Apply(src string, edits []Edit) (string, error)

Apply applies a sequence of edits to the src buffer and returns the result. Edits are applied in order of start offset; edits with the same start offset are applied in they order they were provided.

Apply returns an error if any edit is out of bounds, or if any pair of edits is overlapping.

func ApplyBytes ¶

func ApplyBytes(src []byte, edits []Edit) ([]byte, error)

ApplyBytes is like Apply, but it accepts a byte slice. The result is always a new array.

func SortEdits ¶

func SortEdits(edits []Edit)

SortEdits orders a slice of Edits by (start, end) offset. This ordering puts insertions (end = start) before deletions (end > start) at the same point, but uses a stable sort to preserve the order of multiple insertions at the same point. (Apply detects multiple deletions at the same point as an error.)

func ToUnified ¶

func ToUnified(oldLabel, newLabel, content string, edits []Edit, contextLines int) (string, error)

ToUnified applies the edits to content and returns a unified diff, with contextLines lines of (unchanged) context around each diff hunk. The old and new labels are the names of the content and result files. It returns an error if the edits are inconsistent; see ApplyEdits.

func Unified ¶

func Unified(oldLabel, newLabel, old, new string) string

Unified returns a unified diff of the old and new strings. The old and new labels are the names of the old and new files. If the strings are equal, it returns the empty string.

Types ¶

type Edit ¶

type Edit struct {
	Start, End int    // byte offsets of the region to replace
	New        string // the replacement
}

An Edit describes the replacement of a portion of a text file.

func Bytes ¶

func Bytes(before, after []byte) []Edit

Bytes computes the differences between two byte slices. The resulting edits respect rune boundaries.

func Merge ¶

func Merge(x, y []Edit) ([]Edit, bool)

Merge merges two valid, ordered lists of edits. It returns zero if there was a conflict.

If corresponding edits in x and y are identical, they are coalesced in the result.

If x and y both provide different insertions at the same point, the insertions from x will be first in the result.

TODO(adonovan): this algorithm could be improved, for example by working harder to coalesce non-identical edits that share a common deletion or common prefix of insertion (see the tests). Survey the academic literature for insights.

func Strings ¶

func Strings(before, after string) []Edit

Strings computes the differences between two strings. The resulting edits respect rune boundaries.

func (Edit) String ¶

func (e Edit) String() string

Source Files ¶

diff.go merge.go ndiff.go unified.go

Directories ¶