boone

type CmdTemplateData struct {
	// Dir is the absolute path of the parent directory of Path.
	Dir string

	// HandlerLabel is a copy of Target.Handler.Label.
	HandlerLabel string

	// IncludeGlob pattern from the config file Include responsible for the command being triggered.
	IncludeGlob string

	// IncludeRoot is the ancestor root directory from the config file Include responsible for the
	// command being triggered.
	IncludeRoot string

	// Path is the absolute path of the file/directory that was created or written to.
	Path string

	// TargetLabel is a copy of Target.Label.
	TargetLabel string
}

type Config struct {
	// Data defines how to store program state.
	Data DataConfig

	// Global defines properties which should be applied to all targets, e.g. as default values.
	Global GlobalConfig

	// Target defines file/directory paths to watch and commands to run when they receive writes.
	Target []Target

	// Template holds key/value pairs which can be used in some string fields via {{.key_name}} syntax.
	//
	// Key names must use lowercase due to viper(/mapstructure?) limitation. Convention: "some_key_name".
	// https://github.com/spf13/viper/issues/411
	// https://github.com/spf13/viper/pull/635
	Template map[string]string

	// AutoStartTarget holds an Id for each Target that should run when the main process starts.
	AutoStartTarget []string
	// contains filtered or unexported fields
}

type DataConfig struct {
	// Session defines how to store sessions.
	Session SessionConfig
}

type Dispatcher struct {
	// Clock supports timer mocking for debounce-sensitive tests.
	Clock cage_time.Clock

	// Cooldown is how long to wait after one command finishes before starting another.
	Cooldown time.Duration

	// Executor supports os/exec.Cmd mocking for tests.
	Executor cage_exec.Executor

	// ExecReqCh receives requests from Watcher when a target has been triggered.
	// Sends are blocked only for as long as it takes to manually add them to a slice queue.
	ExecReqCh chan ExecRequest

	// Log receives debug/info-level messages.
	Log *zap.Logger

	// TreePassCh transports messages from the Dispatcher to the UI about the successful execution of all
	// commands of the activity-triggered target and all commands of downstream targets.
	TreePassCh chan TreePass

	// TargetStartCh transports messages from Dispatcher to the UI about newly pending targets and the start
	// of every executed command.
	TargetStartCh chan Status

	// TargetPassCh transports messages from the Dispatcher to the UI about the successful execution of all
	// commands of a single target.
	TargetPassCh chan TargetPass

	// TargetFailCh transports messages from the Dispatcher to the UI about the failed execution of a command.
	TargetFailCh chan Status
	// contains filtered or unexported fields
}

type Exec struct {
	// Cmd holds a single command or multiple commands in a "|" pipeline.
	Cmd string

	// Dir is the working directory.
	//
	// It is relative to Target.Root and Target.Root by default.
	Dir string

	// Timeout is a time.Duration compatible string from the config file that defines
	// how long to wait before cancelling the command.
	Timeout string

	// Env holds "KEY=VALUE" pairs to overwrite in the current environment.
	Env []string
	// contains filtered or unexported fields
}

type ExecRequest struct {
	// Origin is a free-form value, currently only for logging, which indicates the cause
	// of the request.
	Cause string

	// Debounce is how long to wait for file activity to stop before running the target.
	Debounce time.Duration

	// Event describes the filesystem operation which led to the request.
	Event watcher.Event

	// Include is the path pattern responsible for the Watcher capturing the activity.
	Include cage_filepath.Glob

	// RecvTime is when Dispatcher received the ExecRequest.
	//
	// It is used to cancel target runs before they start when the request has alraedy been sent to
	// Dispatcher.runTargetCh but should be ignored because a newer request was received in the meantime.
	RecvTime time.Time

	// Tree holds all targets downstream from the activity-triggered target.
	Tree []TargetTree

	// TargetId is a copy of the Id field of the activity-triggered Target.
	TargetId string

	// TargetLabel is a copy of the Label field of the activity-triggered Target.
	TargetLabel string
}

type GlobalConfig struct {
	// Cooldown is a time.Duration compatible string which selects how long to wait after one command
	// finishes before starting another.
	Cooldown string

	// Exclude are appended to every Target.Exclude list.
	Exclude []cage_filepath.Glob
	// contains filtered or unexported fields
}

type Handler struct {
	// Label is displayed to users in output for reference/debugging/etc. and also
	// provides a documentation in the config file on the intent.
	//
	// It is a required field.
	Label string

	// Exec defines the commands to execute.
	Exec []Exec
}

type ListItemWidget struct {
	// Container is the flexible height/width box which bounds the Header and Body areas.
	Container *tview.Flex

	// Header areas are single-lined and display target labels/statuses/shortcuts in the status list,
	// and display detail types/shortcuts in the status-detail list.
	Header *tview.TextView

	// Body areas expand to use all space unused by the Header and display a snippet of standard error
	// in the status list, and display a detail snippets in the status-detail list.
	Body *tview.TextView
}

type Session struct {
	// Statuses holds one Status per Target which was displayed in the UI when the Session value is
	// created.
	Statuses []Status

	// Version is a copy of the SessionVersion constant when the Session value is created.
	Version int
}

type SessionConfig struct {
	File string
}

type Status struct {
	// Cause explains why the status is in the list.
	Cause TargetStatus

	// Cmd was the final command string after template expansion.
	Cmd string

	// Downstream holds labels of all downstream targets included in the run.
	Downstream []string

	// EndTime is when the Cmd finished.
	EndTime time.Time

	// Err is non-nil if Cmd failed.
	Err string

	// HandlerLabel is from the source of the status.
	HandlerLabel string

	// Include is the one responsible for the capturing the file activity which led to running the target.
	Include cage_filepath.Glob

	// Op is the type of filesystem operation which led to target execution.
	//
	// It is "Create", "Rename", or "Write"
	Op string

	// Path identifies the file whose Op activity triggered the target.
	Path string

	// Pid is the process Id of Cmd.
	Pid []int

	// RunLen is how long Cmd ran.
	RunLen time.Duration

	// StartTime is when Cmd started.
	StartTime time.Time

	// Stderr is collected from Cmd exceution.
	Stderr string

	// Stdout is collected from Cmd exceution.
	Stdout string

	// TargetId is from the source of the status.
	TargetId string

	// TargetLabel is from the source of the status.
	TargetLabel string

	// UpstreamTargetLabel is the one whose activity triggered the handler execution flow
	// that may include one or more (of its) downstream targets. If there were no
	// downstream targets, it should equal the Target field.
	UpstreamTargetLabel string
}

type Target struct {
	// Debounce is a time.Duration compatible string from the config file that defines
	// how long to wait after file activity settles before executing handlers.
	Debounce string

	// Downstream holds all direct descendants.
	//
	// It is generated at startup.
	Downstream []*Target

	// Exclude defines the path patterns of files/directories which should invalidate an Include match.
	Exclude []cage_filepath.Glob

	// Handler defines the commands to run if the target is triggered by write-activity.
	Handler []Handler

	// Id is user-defined, ideally short, and must be unique in the config file.
	//
	// It is an optional field and supports features like upstream-target triggers.
	Id string

	// Include defines the path patterns of files/directories whose write-activity can trigger this target.
	Include []cage_filepath.Glob

	// Label is displayed to users in output for reference/debugging/etc. and also
	// provides a documentation in the config file on the intent.
	//
	// It is a required field.
	Label string

	// Root is the default path prefix value for Include.Root fields.
	Root string

	// Tree holds one item per Target which Dispatcher should execute when this Target is
	// triggered. It includes ths Target in the first item, followed by all downstream
	// targets found recursively.
	//
	// It only holds the minimum details of each target in order to avoid data races,
	// e.g. that might happen with a map of Target/*Target.
	//
	// It is generated at startup.
	Tree []TargetTree

	// Upstream holds Id values of targets that, when triggered, also trigger this target.
	Upstream []string
	// contains filtered or unexported fields
}

type TargetContext struct {
	// Ctx is initialized by Dispatcher when it starts the first handler.
	// If there are multiple handlers, they all share the same value in order
	// to allow Dispatcher to cancel the target regardless of which handler
	// is running.
	Ctx context.Context

	// Cancel is invoked to kill the running command.
	Cancel context.CancelFunc
}

type TargetPass struct {
	// RunLen is how long it took to run a target's command list.
	RunLen time.Duration

	// TargetId is a copy of Target.Id.
	TargetId string
}

type TargetStatus string

type TargetTree struct {
	Id      string
	Label   string
	Handler []Handler
}

type TreePass struct {
	// DispatchTargetId is the first target in the tree and whose activity led to the tree execution.
	DispatchTargetId string
}

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

type Watcher struct {
	// Watcher is the actual filesystem monitor. Watcher is a subscriber of events emitted by the monitor.
	//
	// See NewDispatcher for how it and Watcher are wired together.
	watcher.Watcher

	// PanicCh transports messages from Watcher to the CLI to support cleaner shutdowns.
	PanicCh chan<- interface{}

	// ExecReqCh transports messages from Watcher to the Dispatcher to run activated targets.
	ExecReqCh chan<- ExecRequest

	// AddPathCh transports messages from Watcher to listeners which contain paths to newly
	// created files/directories that are now themselves watched for writes.
	//
	// It is currently only used by tests.
	AddPathCh chan<- string

	// Target is the scope of this Watcher's write-activity detection.
	Target Target

	// Log receives debug/info-level messages.
	Log *zap.Logger
	// contains filtered or unexported fields
}