lib

type Blob interface {
	// ID of the blob.
	ID() string
	// Name of the blob.
	Name() string
	// Path (relative) to the blob.
	Path() string
	//String returns a printable id.
	String() string
}

type BlobWalkCallback func(Blob) error

type BuildResult struct {
	// Module of the build result
	Module *Module
}

type BuildSummary struct {
	// Manifest used to trigger the build
	Manifest *Manifest
	// Completed list of the modules built. This list does not
	// include the modules that were skipped due to
	// the unavailability of a build command for the
	// host platform.
	Completed []*BuildResult
	// Skipped modules due to the unavailability of a build command for
	// the host platform
	Skipped []*Module
}

type Cmd struct {
	Cmd  string
	Args []string `yaml:",flow"`
}

type CmdFailure struct {
	Module *Module
	Err    error
}

type CmdOptions struct {
	Stdin          io.Reader
	Stdout, Stderr io.Writer
	Callback       CmdStageCallback
	FailFast       bool
}

type CmdStage = int

type CmdStageCallback func(mod *Module, s CmdStage, err error)

type Commit interface {
	ID() string
	String() string
}

type DiffDelta struct {
	// NewFile path of the delta
	NewFile string
	// OldFile path of the delta
	OldFile string
}

type Discover interface {
	// ModulesInCommit walks the git tree at a specific commit looking for
	// directories with .mbt.yml file. Returns discovered Modules.
	ModulesInCommit(commit Commit) (Modules, error)
	// ModulesInWorkspace walks current workspace looking for
	// directories with .mbt.yml file. Returns discovered Modules.
	ModulesInWorkspace() (Modules, error)
}

type FilterOptions struct {
	Name       string
	Fuzzy      bool
	Dependents bool
}

type KVP struct {
	Key   string
	Value interface{}
}

type Log interface {
	Info(args ...interface{})
	Infof(format string, args ...interface{})
	Warn(args ...interface{})
	Warnf(format string, args ...interface{})
	Error(error)
	Errorf(format string, args ...interface{})
	Debug(format string, args ...interface{})
}

type Manifest struct {
	Dir     string
	Sha     string
	Modules Modules
}

type ManifestBuilder interface {
	// ByDiff creates the manifest for diff between two commits
	ByDiff(from, to Commit) (*Manifest, error)
	// ByPr creates the manifest for diff between two branches
	ByPr(src, dst string) (*Manifest, error)
	// ByCommit creates the manifest for the specified commit
	ByCommit(sha Commit) (*Manifest, error)
	// ByCommitContent creates the manifest for the content of the
	// specified commit.
	ByCommitContent(sha Commit) (*Manifest, error)
	// ByBranch creates the manifest for the specified branch
	ByBranch(name string) (*Manifest, error)
	// ByCurrentBranch creates the manifest for the current branch
	ByCurrentBranch() (*Manifest, error)
	// ByWorkspace creates the manifest for the current workspace
	ByWorkspace() (*Manifest, error)
	// ByWorkspaceChanges creates the manifest for the changes in workspace
	ByWorkspaceChanges() (*Manifest, error)
}

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

type Modules []*Module

type ProcessManager interface {
	// Exec runs an external command in the context of a module in a manifest.
	// Following actions are performed prior to executing the command:
	// - Current working directory of the target process is set to module path
	// - Initialises important information in the target process environment
	Exec(manifest *Manifest, module *Module, options *CmdOptions, command string, args ...string) error
}

type Reducer interface {
	Reduce(modules Modules, deltas []*DiffDelta) (Modules, error)
}

type Reference interface {
	Name() string
	SymbolicName() string
}

type Repo interface {
	// GetCommit returns the commit object for the specified SHA.
	GetCommit(sha string) (Commit, error)
	// Path of the repository.
	Path() string
	// Diff gets the diff between two commits.
	Diff(a, b Commit) ([]*DiffDelta, error)
	// DiffMergeBase gets the diff between the merge base of from and to and, to.
	// In other words, diff contains the deltas of changes occurred in 'to' commit tree
	// since it diverged from 'from' commit tree.
	DiffMergeBase(from, to Commit) ([]*DiffDelta, error)
	// DiffWorkspace gets the changes in current workspace.
	// This should include untracked changes.
	DiffWorkspace() ([]*DiffDelta, error)
	// Changes returns a an array of DiffDelta objects representing the changes
	// in the specified commit.
	// Return an empty array if the specified commit is the first commit
	// in the repo.
	Changes(c Commit) ([]*DiffDelta, error)
	// WalkBlobs invokes the callback for each blob reachable from the commit tree.
	WalkBlobs(a Commit, callback BlobWalkCallback) error
	// BlobContents of specified blob.
	BlobContents(blob Blob) ([]byte, error)
	// BlobContentsByPath gets the blob contents from a specific git tree.
	BlobContentsFromTree(commit Commit, path string) ([]byte, error)
	// EntryID of a git object in path.
	// ID is resolved from the commit tree of the specified commit.
	EntryID(commit Commit, path string) (string, error)
	// BranchCommit returns the last commit for the specified branch.
	BranchCommit(name string) (Commit, error)
	// CurrentBranch returns the name of current branch.
	CurrentBranch() (string, error)
	// CurrentBranchCommit returns the last commit for the current branch.
	CurrentBranchCommit() (Commit, error)
	// IsEmpty informs if the current repository is empty or not.
	IsEmpty() (bool, error)
	// FindAllFilesInWorkspace returns all files in repository matching given pathSpec, including untracked files.
	FindAllFilesInWorkspace(pathSpec []string) ([]string, error)
	// EnsureSafeWorkspace returns an error workspace is in a safe state
	// for operations requiring a checkout.
	// For example, in git repositories we consider uncommitted changes or
	// a detached head is an unsafe state.
	EnsureSafeWorkspace() error
	// Checkout specified commit into workspace.
	// Also returns a reference to the previous tree pointed by current workspace.
	Checkout(commit Commit) (Reference, error)
	// CheckoutReference checks out the specified reference into workspace.
	CheckoutReference(Reference) error
	// MergeBase returns the merge base of two commits.
	MergeBase(a, b Commit) (Commit, error)
}

type RunResult struct {
	Manifest  *Manifest
	Completed []*Module
	Skipped   []*Module
	Failures  []*CmdFailure
}

type Spec struct {
	Name             string                 `yaml:"name"`
	Build            map[string]*Cmd        `yaml:"build"`
	Commands         map[string]*UserCmd    `yaml:"commands"`
	Properties       map[string]interface{} `yaml:"properties"`
	Dependencies     []string               `yaml:"dependencies"`
	FileDependencies []string               `yaml:"fileDependencies"`
}

type System interface {
	// ApplyBranch applies the manifest of specified branch over a template.
	// Template is retrieved from the commit tree of last commit of that branch.
	ApplyBranch(templatePath, branch string, output io.Writer) error

	// ApplyCommit applies the manifest of specified commit over a template.
	// Template is retrieved from the commit tree of the specified commit.
	ApplyCommit(sha, templatePath string, output io.Writer) error

	// ApplyHead applies the manifest of current branch over a template.
	// Template is retrieved from the commit tree of last commit current branch.
	ApplyHead(templatePath string, output io.Writer) error

	// ApplyLocal applies the manifest of local workspace.
	// Template is retrieved from the current workspace.
	ApplyLocal(templatePath string, output io.Writer) error

	// BuildBranch builds the specified branch.
	// This function accepts FilterOptions to specify which modules to be built
	// within that branch.
	BuildBranch(name string, filterOptions *FilterOptions, options *CmdOptions) (*BuildSummary, error)

	// BuildPr builds changes in 'src' branch since it diverged from 'dst' branch.
	BuildPr(src, dst string, options *CmdOptions) (*BuildSummary, error)

	// Build builds changes between two commits
	BuildDiff(from, to string, options *CmdOptions) (*BuildSummary, error)

	// BuildCurrentBranch builds the current branch.
	// This function accepts FilterOptions to specify which modules to be built
	// within that branch.
	BuildCurrentBranch(filterOptions *FilterOptions, options *CmdOptions) (*BuildSummary, error)

	// BuildCommit builds specified commit.
	// This function accepts FilterOptions to specify which modules to be built
	// within that branch.
	BuildCommit(commit string, filterOptions *FilterOptions, options *CmdOptions) (*BuildSummary, error)

	// BuildCommitChanges builds the changes in specified commit
	BuildCommitContent(commit string, options *CmdOptions) (*BuildSummary, error)

	// BuildWorkspace builds the current workspace.
	// This function accepts FilterOptions to specify which modules to be built
	// within that branch.
	BuildWorkspace(filterOptions *FilterOptions, options *CmdOptions) (*BuildSummary, error)

	// BuildWorkspace builds changes in current workspace.
	BuildWorkspaceChanges(options *CmdOptions) (*BuildSummary, error)

	// IntersectionByCommit returns the manifest of intersection of modules modified
	// between two commits.
	// If we consider M as the merge base of first and second commits,
	// intersection contains the modules that have been changed
	// between M and first and M and second.
	IntersectionByCommit(first, second string) (Modules, error)

	// IntersectionByBranch returns the manifest of intersection of modules modified
	// between two branches.
	// If we consider M as the merge base of first and second branches,
	// intersection contains the modules that have been changed
	// between M and first and M and second.
	IntersectionByBranch(first, second string) (Modules, error)

	// ManifestByDiff creates the manifest for diff between two commits
	ManifestByDiff(from, to string) (*Manifest, error)

	// ManifestByPr creates the manifest for diff between two branches
	ManifestByPr(src, dst string) (*Manifest, error)

	// ManifestByCommit creates the manifest for the specified commit
	ManifestByCommit(sha string) (*Manifest, error)

	// ManifestByCommitContent creates the manifest for the content in specified commit
	ManifestByCommitContent(sha string) (*Manifest, error)

	// ByBranch creates the manifest for the specified branch
	ManifestByBranch(name string) (*Manifest, error)

	// ByCurrentBranch creates the manifest for the current branch
	ManifestByCurrentBranch() (*Manifest, error)

	// ByWorkspace creates the manifest for the current workspace
	ManifestByWorkspace() (*Manifest, error)

	// ByWorkspaceChanges creates the manifest for the changes in workspace
	ManifestByWorkspaceChanges() (*Manifest, error)

	// RunInBranch runs a command in a branch.
	// This function accepts FilterOptions to specify a subset of modules.
	RunInBranch(command, name string, filterOptions *FilterOptions, options *CmdOptions) (*RunResult, error)

	// RunInPr runs a command in modules that have been changed in
	// 'src' branch since it diverged from 'dst' branch.
	RunInPr(command, src, dst string, options *CmdOptions) (*RunResult, error)

	// RunInDiff runs a command in modules that have been changed in 'from'
	// commit since it diverged from 'to' commit.
	RunInDiff(command, from, to string, options *CmdOptions) (*RunResult, error)

	// RunInCurrentBranch runs a command in modules in the current branch.
	// This function accepts FilterOptions to filter the modules included in this
	// operation.
	RunInCurrentBranch(command string, filterOptions *FilterOptions, options *CmdOptions) (*RunResult, error)

	// RunInCommit runs a command in all modules in a commit.
	// This function accepts FilterOptions to filter the modules included in this
	// operation.
	RunInCommit(command, commit string, filterOptions *FilterOptions, options *CmdOptions) (*RunResult, error)

	// RunInCommitContent runs a command in modules modified in a commit.
	RunInCommitContent(command, commit string, options *CmdOptions) (*RunResult, error)

	// RunInWorkspace runs a command in all modules in workspace.
	// This function accepts FilterOptions to filter the modules included in this
	// operation.
	RunInWorkspace(command string, filterOptions *FilterOptions, options *CmdOptions) (*RunResult, error)

	// RunInWorkspaceChanges runs a command in modules modified in workspace.
	RunInWorkspaceChanges(command string, options *CmdOptions) (*RunResult, error)
}

type TemplateData struct {
	Args           map[string]interface{}
	Sha            string
	Env            map[string]string
	Modules        map[string]*Module
	ModulesList    []*Module
	OrderedModules []*Module
}

type UserCmd struct {
	Cmd  string
	Args []string `yaml:",flow"`
	OS   []string `yaml:"os"`
}

type WorkspaceManager interface {
	// CheckoutAndRun checks out the given commit and executes the specified function.
	// Returns an error if current workspace is dirty.
	// Otherwise returns the output from fn.
	CheckoutAndRun(commit string, fn func() (interface{}, error)) (interface{}, error)
}