plugin

type Command struct {
	// Same as cobra.Command.Use
	Use string
	// Same as cobra.Command.Aliases
	Aliases []string
	// Same as cobra.Command.Short
	Short string
	// Same as cobra.Command.Long
	Long string
	// Same as cobra.Command.Hidden
	Hidden bool
	// Flags holds the list of command flags
	Flags []Flag
	// PlaceCommandUnder indicates where the command should be placed.
	// For instance `spellshape scaffold` will place the command at the
	// `scaffold` command.
	// An empty value is interpreted as `spellshape` (==root).
	PlaceCommandUnder string
	// List of sub commands
	Commands []Command
}

type ExecutedCommand struct {
	// Use is copied from Command.Use
	Use string
	// Path contains the command path, e.g. `spellshape scaffold foo`
	Path string
	// Args are the command arguments
	Args []string
	// Full list of args taken from os.Args
	OSArgs []string
	// With contains the plugin config parameters
	With map[string]string
	// contains filtered or unexported fields
}

type ExecutedHook struct {
	// ExecutedCommand gives access to the command attached by the hook.
	ExecutedCommand ExecutedCommand
	// Hook is a copy of the original Hook defined in the Manifest.
	Hook
}

type Flag struct {
	Name      string // name as it appears on command line
	Shorthand string // one-letter abbreviated flag
	Usage     string // help message
	DefValue  string // default value (as text); for usage message
	Type      FlagType
	Value     string
	// Persistent indicates wether or not the flag is propagated on children
	// commands
	Persistent bool
}

type FlagType string

type Hook struct {
	// Name identifies the hook for the client to invoke the correct hook
	// must be unique
	Name string
	// PlaceHookOn indicates the command to register the hooks for
	PlaceHookOn string
}

type Interface interface {
	// Manifest declares the plugin's Command(s) and Hook(s).
	Manifest() (Manifest, error)

	// Execute will be invoked by spellshape when a plugin Command is executed.
	// It is global for all commands declared in Manifest, if you have declared
	// multiple commands, use cmd.Path to distinguish them.
	Execute(cmd ExecutedCommand) error

	// ExecuteHookPre is invoked by spellshape when a command specified by the Hook
	// path is invoked.
	// It is global for all hooks declared in Manifest, if you have declared
	// multiple hooks, use hook.Name to distinguish them.
	ExecuteHookPre(hook ExecutedHook) error
	// ExecuteHookPost is invoked by spellshape when a command specified by the hook
	// path is invoked.
	// It is global for all hooks declared in Manifest, if you have declared
	// multiple hooks, use hook.Name to distinguish them.
	ExecuteHookPost(hook ExecutedHook) error
	// ExecuteHookCleanUp is invoked by spellshape when a command specified by the
	// hook path is invoked. Unlike ExecuteHookPost, it is invoked regardless of
	// execution status of the command and hooks.
	// It is global for all hooks declared in Manifest, if you have declared
	// multiple hooks, use hook.Name to distinguish them.
	ExecuteHookCleanUp(hook ExecutedHook) error
}

type InterfacePlugin struct {
	// Impl Injection
	Impl Interface
}

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

type InterfaceRPCServer struct {
	// This is the real implementation
	Impl Interface
}

type Manifest struct {
	Name string
	// Commands contains the commands that will be added to the list of spellshape
	// commands. Each commands are independent, for nested commands use the
	// inner Commands field.
	Commands []Command
	// Hooks contains the hooks that will be attached to the existing spellshape
	// commands.
	Hooks []Hook
	// SharedHost enables sharing a single plugin server across all running instances
	// of a plugin. Useful if a plugin adds or extends long running commands
	//
	// Example: if a plugin defines a hook on `spellshape chain serve`, a plugin server is instanciated
	// when the command is run. Now if you want to interact with that instance from commands
	// defined in that plugin, you need to enable `SharedHost`, or else the commands will just
	// instantiate separate plugin servers.
	//
	// When enabled, all plugins of the same `Path` loaded from the same configuration will
	// attach it's rpc client to a an existing rpc server.
	//
	// If a plugin instance has no other running plugin servers, it will create one and it will be the host.
	SharedHost bool `yaml:"shared_host"`
}

type Option func(*Plugin)

type Plugin struct {
	// Embed the plugin configuration
	pluginsconfig.Plugin
	// Interface allows to communicate with the plugin via net/rpc.
	Interface Interface
	// If any error occurred during the plugin load, it's stored here
	Error error
	// contains filtered or unexported fields
}