vcs

type BackportCommit struct {
	// Backport is only applied if the commit is reachable from HEAD.
	GuiltyHash string `json:"guilty_hash"`
	// The hash of the commit to cherry-pick.
	FixHash string `json:"fix_hash"`
	// The title of the commit to cherry-pick.
	// It's used to determine whether the fix is already in place.
	FixTitle string `json:"fix_title"`
	// The field is only intended to make config files less cryptic.
	Comment string `json:"comment"`
}

type BaseCommit struct {
	*Commit
	Branches []string
}

type BisectEnv struct {
	Compiler     string
	KernelConfig []byte
}

type BisectResult int

type Bisecter interface {
	// Can be used for last minute preparations like pulling release tags into the bisected repo, which
	// is required to determin the compiler version to use on linux. Can be an empty function.
	PrepareBisect() error

	// Bisect bisects good..bad commit range against the provided predicate (wrapper around git bisect).
	// The predicate should return an error only if there is no way to proceed
	// (it will abort the process), if possible it should prefer to return BisectSkip.
	// Progress of the process is streamed to the provided trace.
	// Returns the first commit on which the predicate returns BisectBad,
	// or multiple commits if bisection is inconclusive due to BisectSkip.
	Bisect(bad, good string, dt debugtracer.DebugTracer, pred func() (BisectResult, error)) ([]*Commit, error)

	// PreviousReleaseTags returns list of preceding release tags that are reachable from the given commit.
	// If the commit itself has a release tag, this tag is not included.
	PreviousReleaseTags(commit, compilerType string) ([]string, error)

	IsRelease(commit string) (bool, error)

	EnvForCommit(defaultCompiler, compilerType, binDir, commit string,
		kernelConfig []byte, backports []BackportCommit) (*BisectEnv, error)
}

type Commit struct {
	Hash       string
	Title      string
	Author     string
	AuthorName string
	Recipients Recipients
	Tags       []string
	Parents    []string
	Date       time.Time
	CommitDate time.Time
	Patch      []byte
}

type CommitShort struct {
	Hash       string
	CommitDate time.Time
}

type ConfigMinimizer interface {
	Minimize(target *targets.Target, original, baseline []byte, types []crash.Type,
		dt debugtracer.DebugTracer, pred func(test []byte) (BisectResult, error)) ([]byte, error)
}

type FileContent struct {
	File    string
	Content string
}

type Git struct {
	Dir     string
	Sandbox bool
	Env     []string
	// contains filtered or unexported fields
}

type ModifiedFile struct {
	Name     string
	LeftHash string
}

type RecipientInfo struct {
	Address mail.Address
	Type    RecipientType
}

type RecipientType int

type Recipients []RecipientInfo

type Repo interface {
	// Poll checkouts the specified repository/branch.
	// This involves fetching/resetting/cloning as necessary to recover from all possible problems.
	// Returns hash of the HEAD commit in the specified branch.
	Poll(repo, branch string) (*Commit, error)

	// CheckoutBranch checkouts the specified repository/branch.
	CheckoutBranch(repo, branch string) (*Commit, error)

	// CheckoutCommit checkouts the specified repository on the specified commit.
	CheckoutCommit(repo, commit string) (*Commit, error)

	// SwitchCommit checkouts the specified commit without fetching.
	SwitchCommit(commit string) (*Commit, error)

	// Commit returns info about the specified commit hash.
	// The commit may be the special value HEAD for the current commit.
	Commit(com string) (*Commit, error)

	// GetCommitByTitle finds commit info by the title. If the commit is not found, nil is returned.
	// Remote is not fetched and only commits reachable from the checked out HEAD are searched
	// (e.g. do CheckoutBranch before).
	GetCommitByTitle(title string) (*Commit, error)

	// GetCommitsByTitles is a batch version of GetCommitByTitle.
	// Returns list of commits and titles of commits that are not found.
	GetCommitsByTitles(titles []string) ([]*Commit, []string, error)

	// ExtractFixTagsFromCommits extracts fixing tags for bugs from git log.
	// Given email = "[email protected]", it searches for tags of the form "[email protected]"
	// and returns commits with these tags.
	ExtractFixTagsFromCommits(baseCommit, email string) ([]*Commit, error)

	// ReleaseTag returns the latest release tag that is reachable from the given commit.
	ReleaseTag(commit string) (string, error)

	// Returns true if the current tree contains the specified commit.
	// Remote is not fetched and only commits reachable from the checked out HEAD are searched
	// (e.g. do CheckoutBranch before).
	Contains(commit string) (bool, error)

	// LatestCommits lists all latest commit hashes well as their commit dates.
	// If afterCommit is specified, the output only includes the commits from which afterCommit is reachable.
	// If afterDate is specified, the output only includes the newe commits.
	LatestCommits(afterCommit string, afterDate time.Time) ([]CommitShort, error)

	// Object returns the contents of a git repository object at the particular moment in history.
	Object(name, commit string) ([]byte, error)

	// MergeBases returns good common ancestors of the two commits.
	MergeBases(firstCommit, secondCommit string) ([]*Commit, error)

	// CommitExists check for the commit presence in local checkout.
	CommitExists(commit string) (bool, error)

	// PushCommit is used to store commit in remote repo.
	PushCommit(repo, commit string) error
}

type RepoOpt int

type TestRepo struct {
	Dir string

	Commits map[string]map[string]*Commit
	// contains filtered or unexported fields
}