package keymap

Import Path
	github.com/reeflective/readline/internal/keymap (on go.dev)

Dependency Relation
	imports 8 packages, and imported by 3 packages

Involved Source Files

	    completion.go
	    config.go
	    cursor.go
	    dispatch.go
	    emacs.go
	    engine.go
	    mode.go
	    pending.go
	    vim.go
Package-Level Type Names (total 3)

	/* sort by: alphabet | popularity */
	 type CursorStyle string (basic type)
		CursorStyle is the style of the cursor
		in a given input mode/submode.

		Methods (only one)
			( CursorStyle) String() string
				String - Implements fmt.Stringer.

		Implements (at least 2)
			 CursorStyle : expvar.Var
			 CursorStyle : fmt.Stringer

	 type Engine (struct)
		Engine is used to manage the main and local keymaps for the shell.

		Methods (total 21)
			(*Engine) ActiveCommand() inputrc.Bind
				ActiveCommand returns the sequence/command currently being ran.

			(*Engine) CancelPending()
				CancelPending is used by commands that have been registering themselves
				as waiting for a pending operator, but have actually been called twice
				in a row (eg. dd/yy in Vim mode). This removes those commands from queue.

			(*Engine) Commands() map[string]func()
				Commands returns the map of all command functions available to the shell.
				This includes the builtin commands (emacs/Vim/history/completion/etc), as
				well as any functions added by the user through Keymap.Register().
				The keys of this map are the names of each corresponding command function.

			(*Engine) InputIsTerminator() bool
				InputIsTerminator returns true when current input keys are one of
				the configured or builtin "terminators", which can be configured
				in .inputrc with the isearch-terminators variable.

			(*Engine) IsEmacs() bool
				IsEmacs returns true if the main keymap is one of the emacs modes.

			(*Engine) IsPending() bool
				IsPending returns true when invoked from within the command
				that also happens to be the next in line of pending commands.

			(*Engine) Local() Mode
				Local returns the local keymap.

			(*Engine) Main() Mode
				Main returns the local keymap.

			(*Engine) NonIncrementalSearchStart()
				NonIncrementalSearchStart is used to notify the keymap dispatchers
				that are using a minibuffer, and that the set of valid commands
				should be restrained to a few ones (self-insert/abort/rubout...).

			(*Engine) NonIncrementalSearchStop()
				NonIncrementalSearchStop notifies the keymap dispatchers
				that we stopped editing a non-incremental search minibuffer.

			(*Engine) Pending()
				Pending registers a command as waiting for another command to run first,
				such as yank/delete/change actions, which accept/require a movement command.

			(*Engine) PendingCursor() (restore func())
				PendingCursor changes the cursor to pending mode,
				and returns a function to call once done with it.

			(*Engine) PrintBinds(keymap string, inputrcFormat bool)
				PrintBinds displays a list of currently bound commands (and their sequences)
				to the screen. If inputrcFormat is true, it displays it formatted such that
				the output can be reused in an .inputrc file.

			(*Engine) PrintCursor(keymap Mode)
				PrintCursor prints the cursor for the given keymap mode,
				either default value or the one specified in inputrc file.

			(*Engine) Register(commands map[string]func())
				Register adds command functions to the list of available commands.
				Each key of the map should be a unique name, not yet used by any
				other builtin/user command, in order not to "overload" the builtins.

			(*Engine) ReloadConfig(opts ...inputrc.Option) (err error)
				ReloadConfig parses all valid .inputrc configurations and immediately
				updates/reloads all related settings (editing mode, variables behavior, etc.)

			(*Engine) ResetLocal()
				ResetLocal deactivates the local keymap of the shell.

			(*Engine) RunPending()
				RunPending runs any command with pending execution.

			(*Engine) SetLocal(keymap string)
				SetLocal sets the local keymap of the shell.
				Valid builtin keymaps are:
				- vi-opp, vi-visual. (used in commands like yank, change, delete, etc.)
				- isearch, menu-select (used in search and completion).

			(*Engine) SetMain(keymap string)
				SetMain sets the main keymap of the shell.
				Valid builtin keymaps are:
				- emacs, emacs-meta, emacs-ctlx, emacs-standard.
				- vi, vi-insert, vi-command, vi-move.

			(*Engine) UpdateCursor()
				UpdateCursor reprints the cursor corresponding to the current keymaps.

		As Outputs Of (at least one exported)
			func NewEngine(keys *core.Keys, i *core.Iterations, opts ...inputrc.Option) (*Engine, *inputrc.Config)
		As Inputs Of (at least 4)
			func MatchLocal(eng *Engine) (bind inputrc.Bind, command func(), prefix bool)
			func MatchMain(eng *Engine) (bind inputrc.Bind, command func(), prefix bool)
			func github.com/reeflective/readline/internal/completion.NewEngine(h *ui.Hint, km *Engine, o *inputrc.Config) *completion.Engine
			func github.com/reeflective/readline/internal/ui.NewPrompt(line *core.Line, cursor *core.Cursor, keymaps *Engine, opts *inputrc.Config) *ui.Prompt

	 type Mode string (basic type)
		Mode is a root keymap mode for the shell.
		To each of these keymap modes is bound a keymap.

		As Outputs Of (at least 2)
			func (*Engine).Local() Mode
			func (*Engine).Main() Mode
		As Inputs Of (at least one exported)
			func (*Engine).PrintCursor(keymap Mode)


Package-Level Functions (total 3)

	 func MatchLocal(eng *Engine) (bind inputrc.Bind, command func(), prefix bool)
		MatchLocal incrementally attempts to match cached input keys against the local keymap.
		Returns the bind if matched, the corresponding command, and if we only matched by prefix.

	 func MatchMain(eng *Engine) (bind inputrc.Bind, command func(), prefix bool)
		MatchMain incrementally attempts to match cached input keys against the local keymap.
		Returns the bind if matched, the corresponding command, and if we only matched by prefix.

	 func NewEngine(keys *core.Keys, i *core.Iterations, opts ...inputrc.Option) (*Engine, *inputrc.Config)
		NewEngine is a required constructor for the keymap modes manager.
		It initializes the keymaps to their defaults or configured values.


Package-Level Constants (total 12)

	const Emacs = "emacs"
		Editor.

	const EmacsCtrlX = "emacs-ctlx"
		These are the root keymaps used in the readline shell.
		Their functioning is similar to how ZSH organizes keymaps.

	const EmacsMeta = "emacs-meta"
		These are the root keymaps used in the readline shell.
		Their functioning is similar to how ZSH organizes keymaps.

	const EmacsStandard = "emacs-standard"
		These are the root keymaps used in the readline shell.
		Their functioning is similar to how ZSH organizes keymaps.

	const Isearch = "isearch"
		Completion and search.

	const MenuSelect = "menu-select"
		These are the root keymaps used in the readline shell.
		Their functioning is similar to how ZSH organizes keymaps.

	const Vi = "vi"
		These are the root keymaps used in the readline shell.
		Their functioning is similar to how ZSH organizes keymaps.

	const ViCommand = "vi-command"
		These are the root keymaps used in the readline shell.
		Their functioning is similar to how ZSH organizes keymaps.

	const ViInsert = "vi-insert"
		These are the root keymaps used in the readline shell.
		Their functioning is similar to how ZSH organizes keymaps.

	const ViMove = "vi-move"
		These are the root keymaps used in the readline shell.
		Their functioning is similar to how ZSH organizes keymaps.

	const ViOpp = "vi-opp"
		These are the root keymaps used in the readline shell.
		Their functioning is similar to how ZSH organizes keymaps.

	const Visual = "vi-visual"
		These are the root keymaps used in the readline shell.
		Their functioning is similar to how ZSH organizes keymaps.

The pages are generated with Golds v0.8.2. (GOOS=linux GOARCH=amd64)
Golds is a Go 101 project developed by Tapir Liu.
PR and bug reports are welcome and can be submitted to the issue list.
Please follow @zigo_101 (reachable from the left QR code) to get the latest news of Golds.