gitdiff

type Applier ¶

type Applier struct {
	// contains filtered or unexported fields
}

Applier applies changes described in fragments to source data. If changes are described in multiple fragments, those fragments must be applied in order, usually by calling ApplyFile.

By default, Applier operates in "strict" mode, where fragment content and positions must exactly match those of the source.

If an error occurs while applying, methods on Applier return instances of *ApplyError that annotate the wrapped error with additional information when available. If the error is because of a conflict between a fragment and the source, the wrapped error will be a *Conflict.

While an Applier can apply both text and binary fragments, only one fragment type can be used without resetting the Applier. The first fragment applied sets the type for the Applier. Mixing fragment types or mixing fragment-level and file-level applies results in an error.

func NewApplier(src io.ReaderAt) *Applier

func (a *Applier) ApplyBinaryFragment(dst io.Writer, f *BinaryFragment) error

func (a *Applier) ApplyFile(dst io.Writer, f *File) error

func (a *Applier) ApplyTextFragment(dst io.Writer, f *TextFragment) error

func (a *Applier) Flush(dst io.Writer) (err error)

func (a *Applier) Reset(src io.ReaderAt)

type ApplyError ¶

type ApplyError struct {
	// Line is the one-indexed line number in the source data
	Line int64
	// Fragment is the one-indexed fragment number in the file
	Fragment int
	// FragmentLine is the one-indexed line number in the fragment
	FragmentLine int
	// contains filtered or unexported fields
}

ApplyError wraps an error that occurs during patch application with additional location information, if it is available.

func (e *ApplyError) Error() string

func (e *ApplyError) Unwrap() error

type BinaryFragment ¶

type BinaryFragment struct {
	Method BinaryPatchMethod
	Size   int64
	Data   []byte
}

BinaryFragment describes changes to a binary file.

type BinaryPatchMethod ¶

type BinaryPatchMethod int

BinaryPatchMethod is the method used to create and apply the binary patch.

const (
	// BinaryPatchDelta indicates the data uses Git's packfile encoding
	BinaryPatchDelta BinaryPatchMethod = iota
	// BinaryPatchLiteral indicates the data is the exact file content
	BinaryPatchLiteral
)

type Conflict ¶

type Conflict struct {
	// contains filtered or unexported fields
}

Conflict indicates an apply failed due to a conflict between the patch and the source content.

Users can test if an error was caused by a conflict by using errors.Is with an empty Conflict:

    if errors.Is(err, &Conflict{}) {
	       // handle conflict
    }

func (c *Conflict) Error() string

func (c *Conflict) Is(other error) bool

type File ¶

type File struct {
	OldName string
	NewName string

	IsNew    bool
	IsDelete bool
	IsCopy   bool
	IsRename bool

	OldMode os.FileMode
	NewMode os.FileMode

	OldOIDPrefix string
	NewOIDPrefix string
	Score        int

	PatchHeader *PatchHeader

	// TextFragments contains the fragments describing changes to a text file. It
	// may be empty if the file is empty or if only the mode changes.
	TextFragments []*TextFragment

	// IsBinary is true if the file is a binary file. If the patch includes
	// binary data, BinaryFragment will be non-nil and describe the changes to
	// the data. If the patch is reversible, ReverseBinaryFragment will also be
	// non-nil and describe the changes needed to restore the original file
	// after applying the changes in BinaryFragment.
	IsBinary              bool
	BinaryFragment        *BinaryFragment
	ReverseBinaryFragment *BinaryFragment
}

File describes changes to a single file. It can be either a text file or a binary file.

type Line ¶

type Line struct {
	Op   LineOp
	Line string
}

Line is a line in a text fragment.

func (fl Line) New() bool

func (fl Line) NoEOL() bool

func (fl Line) Old() bool

func (fl Line) String() string

type LineOp ¶

type LineOp int

LineOp describes the type of a text fragment line: context, added, or removed.

const (
	// OpContext indicates a context line
	OpContext LineOp = iota
	// OpDelete indicates a deleted line
	OpDelete
	// OpAdd indicates an added line
	OpAdd
)

func (op LineOp) String() string

type LineReaderAt ¶

type LineReaderAt interface {
	ReadLinesAt(lines [][]byte, offset int64) (n int, err error)
}

LineReaderAt is the interface that wraps the ReadLinesAt method.

ReadLinesAt reads len(lines) into lines starting at line offset. It returns the number of lines read (0 <= n <= len(lines)) and any error encountered. Line numbers are zero-indexed.

If n < len(lines), ReadLinesAt returns a non-nil error explaining why more lines were not returned.

Lines read by ReadLinesAt include the newline character. The last line does not have a final newline character if the input ends without one.

type PatchHeader ¶

type PatchHeader struct {
	// The SHA of the commit the patch was generated from. Empty if the SHA is
	// not included in the header.
	SHA string

	// The author details of the patch. If these details are not included in
	// the header, Author is nil and AuthorDate is the zero time.
	Author     *PatchIdentity
	AuthorDate time.Time

	// The committer details of the patch. If these details are not included in
	// the header, Committer is nil and CommitterDate is the zero time.
	Committer     *PatchIdentity
	CommitterDate time.Time

	// The title and body of the commit message describing the changes in the
	// patch. Empty if no message is included in the header.
	Title string
	Body  string

	// If the preamble looks like an email, ParsePatchHeader will
	// remove prefixes such as `Re: ` and `[PATCH v3 5/17]` from the
	// Title and place them here.
	SubjectPrefix string

	// If the preamble looks like an email, and it contains a `---`
	// line, that line will be removed and everything after it will be
	// placed in BodyAppendix.
	BodyAppendix string
}

PatchHeader is a parsed version of the preamble content that appears before the first diff in a patch. It includes metadata about the patch, such as the author and a subject.

func ParsePatchHeader(s string) (*PatchHeader, error)

func (h *PatchHeader) Message() string

type PatchIdentity ¶

type PatchIdentity struct {
	Name  string
	Email string
}

PatchIdentity identifies a person who authored or committed a patch.

func ParsePatchIdentity(s string) (PatchIdentity, error)

func (i PatchIdentity) String() string

type TextFragment ¶

type TextFragment struct {
	Comment string

	OldPosition int64
	OldLines    int64

	NewPosition int64
	NewLines    int64

	LinesAdded   int64
	LinesDeleted int64

	LeadingContext  int64
	TrailingContext int64

	Lines []Line
}

TextFragment describes changed lines starting at a specific line in a text file.

func (f *TextFragment) Header() string

func (f *TextFragment) Raw(op LineOp) string

func (f *TextFragment) Validate() error