All Classes and Interfaces

Class
Description
A cell sizing strategy that forces a fixed width, expressed in number of characters.
Abstract base class to resolve method arguments from a named value, e.g.
Represents a named value declaration.
Base implementation of a Cell.
Base class for completion script commands providing functionality for resource handling and templating with antrl stringtemplate.
Base class for components.
Base implementation of a Control.
Base implementation of a ListCell.
Base abstract NodeVisitor which visits all nodes allowing user to implement callback methods.
Base component for selectors which provide selectable lists.
Class keeping item state.
Context interface on a selector component sharing content.
Base class helping to build shell components.
Base class for components which work on a simple text input.
 
 
Message levels which can be used to alter how message is shown.
Base implementation of a View and its parent interface Control providing some common functionality for implementations.
A strategy interface for performing text alignment.
EventLoop.EventLoopProcessor converting incoming message into animation tick messages.
 
AppView provides an opinionated terminal UI application view controlling main viewing area, menubar, statusbar and modal window system.
ViewEvent indicating direction for a next selection.
Direction where next selection should go.
Resolver for @Header arguments.
A TableModel backed by a row-first array.
Takes data from underlying char array.
 
Interface to generate abstract syntax tree from tokens.
Representing result from tokens to ast tree generation.
Default implementation of an Ast.
Represents a node in an abstract syntax tree and knows about Token.
A ResultHandler that knows how to render JLine's AttributedCharSequence.
Auto-configuration imports for typical Shell tests.
Annotation that can be applied to a test class to enable and configure auto-configuration of shell client.
A SizeConstraints implementation that splits lines at space boundaries and returns an extent with minimal and maximal width requirements.
Indicates whether or not a command is currently available.
Interface resolving Availability.
A ReflectiveProcessor implementation that registers methods of a return type Availability from a target which is a class.
Base implementation of a ComponentContext.
Base impl for ConfirmationInputSpec.
Base impl for specs.
Base spec for other specs.
Base impl for MultiItemSelectorSpec.
Base impl for PathInputSpec.
Base impl for SingleItemSelectorSpec.
Base impl for StringInputSpec.
Completion script generator for a bash.
A table model that is backed by a list of beans.
This represents a directive to set some borders on cells of a table.
Provides support for different styles of borders, using simple or fancy ascii art.
BoxView is a View with an empty background and optional border and title.
ButtonView is a View with border and text acting as a button.
 
 
Base interface for all cells.
This is used to specify where some components of a Table may be applied.
Contains factory methods for commonly used CellMatchers.
Provides an enum with names for the supported character sets.
Provides the (graphical) character sets.
 
 
 
ANSI console related commands.
Marker interface for beans providing clear functionality to the shell.
 
 
Annotation marking a method to be a candicate for a shell command target.
Encapsulates help metadata about a shell command.
Interface representing an alias in a command.
Default implementation of CommandAlias.
Node representing a command argument.
Annotation marking a method having Availability.
Interface defining contract to handle existing CommandRegistrations.
Default implementation of a CommandCatalog.
 
Interface to customize a CommandCatalog.
Interface containing information about current command execution.
Default implementation of a CommandContext.
Implementation of a HandlerMethodArgumentResolver resolving CommandContext.
Interface to be implemented by objects that can resolve exceptions thrown during command processing, in the typical case error response.
Interface to evaluate a result from a command with an arguments.
 
 
 
Default implementation of a CommandExecution.
 
Interface representing an exit code in a command.
 
Holder for handling some processing, typically with CommandExceptionResolver.
 
Helper class to make it easier to work with command registrations and how those are used with parser model.
Node representing a command.
Indicates that a command exists but is currently not invokable.
A result to be handled by the ResultHandler when no command could be mapped to user input
Provider for a message used within CommandNotFoundResultHandler.
ResultHandler for CommandNotFound using CommandNotFoundMessageProvider to provide an error message.
Interface representing an option in a command.
Default implementation of CommandOption.
Interface parsing arguments for a CommandRegistration.
Default implementation of a CommandParser.
 
Result of a parsing CommandOption with an argument.
Results of a CommandParser.
Default implementation of a CommandParser.CommandParserResult.
Default implementation of a CommandParser.CommandParserResults.
Interface defining a command registration endpoint.
Spec defining an alias.
 
Builder interface for CommandRegistration.
Interface used to supply instance of a CommandRegistration.Builder.
 
 
 
 
 
 
 
 
Spec defining an error handling.
Spec defining an exit code.
 
 
Spec defining help options.
Enumeration of option arity values.
Interface used to modify option long name.
Spec defining an option.
Encapsulates info for CommandRegistration.TargetSpec.
 
 
Spec defining a target.
Delegate used by EnableCommandRegistrar and CommandScanRegistrar to register a bean definition(s) for a @Command class.
Callback interface that can be used to customize a CommandRegistration.Builder.
Interface to resolve currently existing commands.
Configures the base packages used when scanning for @Comamnd classes.
ImportBeanDefinitionRegistrar for @CommandScan.
A ValueProvider that can be used to auto-complete names of shell commands.
 
 
An extension of ParsedLine that, being aware of the quoting and escaping rules of the Parser that produced it, knows if and how a completion candidate should be escaped/quoted.
Command to create a shell completion files, i.e.
Marker interface used in auto-config.
Represents the buffer context in which completion was triggered.
Represents a proposal for TAB completion, made not only of the text to append, but also metadata about the proposal.
Interface resolving completion proposals.
Interface resolving completion proposals.
Contract for base component context having access to basic key/value pairs.
Wizart providing an implementation which allows more polished way to ask various inputs from a user using shell style components for simple text/path input, single select and multi-select.
 
Interface for a wizard builder.
Results from a flow run.
 
 
 
 
Auto-configuration for ComponentFlow.
 
Callback interface that can be used to customize a ComponentFlow.Builder.
Component for a confirmation question.
 
Interface for string input spec builder.
Base interface for all controls.
 
Current cursor shape as described by https://vt100.net/docs/vt510-rm/DECSCUSR.html.
 
A decorator Aligner that checks the Aligner invariants contract, useful for debugging.
A TextWrapper that delegates to another but makes sure that the contract is not violated.
Default impl for BaseConfirmationInput.
Default implementation of an EventLoop.
A very simple formatter that uses Object.toString() and splits on newlines.
Default impl for BaseMultiItemSelector.
Default impl for BasePathInput.
A simple ResultHandler that deals with Objects (hence comes as a last resort) and prints the Object.toString() value of results to standard out.
Default implementation of a Screen.
Default impl for SelectItem.
Default ShellApplicationRunner which dispatches to the first ordered ShellRunner able to handle the shell.
Default implementation of a ShellContext.
Default impl for BaseSingleItemSelector.
Default impl for BaseStringInput.
A Text wrapper that wraps at "word" boundaries.
DialogView is a View with border, number of buttons and area for a generic content.
 
 
Record representing dimensions width and height.
Node representing
Encapsulating Directive with its fields, name and value.
Interface for an implementation which is able to return list of AttributedString usually used together with Display.
 
 
Enable support for @Command annotated classes.
ImportBeanDefinitionRegistrar for @EnableCommands.
A ValueProvider that knows how to complete values for Enum typed parameters.
EventLoop is a central place where all eventing will be orchestrated for a lifecycle of a component.
Contract to process event loop messages, possibly translating an event into some other type of event or events.
Type of an events handled by an EventLoop.
Annotation for handling exceptions in specific command classes and/or its methods.
 
Defines exit code.
Auto-configuration for exit codes.
Interface to provide exception for an exit code.
Interface used with implementation of a boot's ExitCodeExceptionMapper in a context of spring-shell spesific one.
This exception, when thrown and caught, will ask the shell to gracefully shutdown.
Shameful copy-paste of JLine's DefaultParser which creates CompletingParsedLine.
Base class defining a settings for figures.
An InputProvider that reads input from file-like sources.
A ValueProvider that can populate names of local Files, either absolute or relative to the current working directory.
A Formatter is responsible for the initial rendering of a value to lines of text.
 
Base implementation suitable for use in most environments.
Denotes how a graphic set is designated.
 
GridView is a layout container with no initial views.
A command to display help about all available commands.
Marker interface for beans providing help functionality to the shell.
A command that displays all previously run commands, optionally dumping to a file readable by Script.
Marker interface for beans providing history functionality to the shell.
 
Represents the input buffer to the shell.
To be implemented by components able to provide a "line" of user input, whether interactively or by batch.
InputView is used as a text input.
 
 
Enumeration for modes shell is operating.
A ShellRunner that bootstraps the shell in interactive mode.
 
Encapsulates information about a handler method consisting of a method and a bean.
 
The main terminal emulator class.
Terminal that reflects obtained commands and text at TerminalDisplay(handles change of cursor position, screen size etc) and TerminalTextBuffer(stores printed text)
 
 
 
 
Shell implementation using JLine to capture input and trigger completions.
 
 
 
 
mask special keys unicode keys ascii keys [ ] [ ] [ ] [ ] 31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 09 08 07 06 05 04 03 02 01 00
 
 
Handles Key events in a form of KeyHandler.KeyHandlerArgs and returns KeyHandler.KeyHandlerResult.
Arguments for a KeyHandler.
Result from a KeyHandler.
A text alignment strategy that aligns text horizontally so that all instances of some special character(s) line up perfectly in a column.
A SizeConstraints implementation that is tailored to rendering a series of key = value pairs.
A TextWrapper implementation tailored for key-value rendering (working in concert with KeyValueSizeConstraints, KeyValueHorizontalAligner), that tries its best to vertically align some delimiter character (default '=').
Interface to tokenize arguments into tokens.
Default implementation of a Lexer.
Representing result from Lexer tokenisation.
 
Holds styled characters lines
Extension of a Cell to make it aware of an item style and selection state.
 
ListView is a View showing items in a vertical list.
Specifies how a item shows selection state.
ViewEvent indicating that selected item has been requested to open.
ViewEvent indicating that selected item has changed.
A formatter suited for key-value pairs, that renders each mapping on a new line.
 
MenuBarView shows items horizontally and is typically used in layouts which builds complete terminal UI's.
MenuBarView.MenuBarItem represents an item in a MenuBarView.
MenuView shows MenuView items vertically and is typically used in layouts which builds complete terminal UI's.
MenuView.Menu represents an item in a MenuView being a specialisation of MenuView.MenuItem indicating it having a sub-menu.
MenuView.MenuItem represents an item in a MenuView.
Specifies how a MenuView.MenuItem shows selection state.
ViewEvent indicating that selected item has been requested to open.
ViewEvent indicating that selected item has changed.
Encapsulating ParserMessage with position and inserts.
 
Strategy interface for registering commands.
 
 
unused modifier button type [ ] [ ] [ ] [ ] 31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 09 08 07 06 05 04 03 02 01 00
 
 
 
 
Handles mouse events in a form of MouseHandler.MouseHandlerArgs and returns MouseHandler.MouseHandlerResult.
Arguments for a MouseHandler.
Result from a MouseHandler.
Component able to pick multiple items.
Interface for multi input spec builder.
 
Interface to vising nodes.
A ShellRunner that executes commands without entering interactive shell mode.
Callback interface that can be implemented by beans wishing to customize the auto-configured NonInteractiveShellRunner.
Nonterminal node means that it can have children and doesn't necessarily terminal ast tree branch.
 
A sizing strategy that will impose the longest line width on cells.
 
 
 
Annotation marking a method parameter to be a candicate for an option.
Node representing an option argument.
Resolver for @Option arguments.
Support facilities for CommandRegistration.OptionNameModifier providing common naming types.
Node representing an option.
Annotation marking a method parameter which completion proposals should be used.
 
 
Thrown when no ParameterResolver is found for a parameter during a resolve operation.
Thrown when one or more parameters fail bean validation constraints.
Displays validation errors on the terminal.
Interface to parse command line arguments.
Default implementation of a NodeVisitor.
Default implementation of a Parser.
Results from a Parser containing needed information like resolved CommandRegistration, list of CommandOption instances, errors and directive.
 
 
 
 
Contains all the messages that can be produced during parsing.
 
 
 
 
Component for a simple path input.
 
Interface for path input spec builder.
Component resolving Path based on base path and optional search term.
Result from a path scanning.
Class defining configuration for path search.
Context for PathSearch.
Domain class for path view item.
Holder class keeping Path and SearchMatchResult.
Record representing position x and y.
Called at each REPL cycle to decide what the prompt should be.
A command that terminates the running shell.
Marker interface for beans providing quit functionality to the shell.
Record representing coordinates x, y and its width and height.
Default implementation of a CompletionResolver.
 
Implementations know how to deal with results of method invocations, whether normal results or exceptions thrown.
Used for explicit configuration of ResultHandlers.
 
A service interface for result handling.
 
Enumeration of a modes instructing how resultValue is handled.
Screen is representing a virtual area which is sitting between a user and lower level jline terminal providing convenient methods working with visible content.
Interface to write into a Screen.
Builder interface for a Screen.Writer.
 
A command that can read and execute other commands from a file.
Marker interface for beans providing script functionality to the shell.
A ShellRunner that looks for process arguments that start with @, which are then interpreted as references to script files to run and exit.
Interface defining a search match for text agains pattern.
Defines an interface for SearchMatch.
 
 
Interface to match given text with a pattern into a result.
Interface defining result used in SearchMatch.
 
 
Interface for selectitem contract in selectors.
 
 
 
 
 
 
Main class implementing a shell loop.
Marker interface for a main spring shell ApplicationRunner.
Entry point for assertion methods for shell components.
 
 
Used to indicate the default group of shell commands, either at the package or class level.
Indicates that an annotated class may contain shell methods (themselves annotated with ShellMethod) that is, methods that may be invoked reflectively by the shell.
Interface defining a contract for a context which allows to loosely connect different components together and keep things alive between commands.
 
Interface to provide shell spesific ConversionService.
Shell spesific message builder.
Adds standard shell Headers.
Used to mark a method as invokable via Spring Shell.
Resolves method parameters by delegating to a list of registered HandlerMethodArgumentResolvers.
Used to customize the name of the method used to indicate availability of a command.
Used to customize handling of a ShellMethod parameter.
 
Resolver for @ShellOption arguments.
Interface for shell runners.
 
 
 
Interface representing a shell screen.
 
Asserts for ShellScreen.
Annotation that can be used for a Shell test that focuses only on Shell components.
Client for terminal session which can be used as a programmatic way to interact with a shell application.
 
Builder interface for ShellClient.
 
 
 
 
 
 
 
 
 
TestContextBootstrapper for @ShellTest support.
TypeExcludeFilter for @ShellTest.
Interface sequencing various things into terminal aware text types.
 
An horizontal alignment strategy that allows alignment to the left, center or right.
Alignment strategy that allows simple vertical alignment to top, middle or bottom.
Component able to pick single item.
Interface for single item selector spec builder.
Strategy for computing the dimensions of a table cell.
Holds both a minimum and maximum width.
Creates supporting beans for running the Shell
Configuration properties for shell.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Configuration properties for shell test.
A command to display the full stacktrace when an error occurs.
Marker interface for beans providing stacktrace functionality to the shell.
Sets up all required beans for supporting the standard Shell API.
Creates beans for standard commands.
The standard implementation of MethodTargetRegistrar for new shell applications, resolves methods annotated with ShellMethod on ShellComponent beans.
Lightweight type-safe header accessor avoiding object creation just to access a header.
StatusBarView shows items horizontally and is typically used in layouts which builds complete terminal UI's.
ViewEvent indicating that selected item has been requested to open.
StatusBarView.StatusItem represents an item in a StatusBarView.
 
Component for a simple string input.
 
Interface for string input spec builder.
ST AttributeRenderer which knows to use format string to render strings into jline StyleExpression based on theming settings.
General interface that obtains styled range of characters at coordinates (x, y) when the screen starts at startRow
 
Base class defining a settings for styles.
 
 
This is the central API for table rendering.
A builder class to incrementally configure a Table.
Abstracts away the contract a Table will use to retrieve tabular data.
Helper class to build a TableModel incrementally.
Utility class used to create and configure typical Tables.
Provides a tabulator that keeps track of the tab stops of a terminal.
 
Template executor which knows to use styling.
Executes terminal commands interpreted by Emulator, receives text
Terminal node means that it is end of ast tree branch.
Base class for ResultHandlers that rely on JLine's Terminal.
 
 
Callback interface that can be used to customize a Terminal via its TerminalBuilder.
Represents data communication interface for terminal.
 
 
 
 
 
 
 
Sends a response from the terminal emulator.
 
 
 
 
To be implemented by command result objects that can adapt to the terminal size when they are being rendered.
A ResultHandler that prints TerminalSizeAware according to the Terminal size.
Runs terminal emulator.
Buffer for storing styled text data.
 
TerminalUI is a main component orchestrating terminal, eventloop, key/mouse events and view structure to work together.
 
Builder that can be used to configure and create a TerminalUI.
Callback interface that can be used to customize a TerminalUI.
 
 
 
 
A strategy for applying text wrapping/cropping given a cell width.
Contract representing a theme with its name and settings.
 
Registry which stores Theme's with its name.
Service which helps to do various things with styles.
Base class defining a settings for themes.
 
A ResultHandler that prints thrown exceptions messages in red.
 
 
Takes data from and sends it back to TTY input and output streams via TtyConnector
Interface to tty.
 
 
Interface providing a Path to a location where user level runtime configuration files are strored.
 
Some text utilities.
Beans implementing this interface are queried during TAB completion to gather possible values of a parameter.
A result for a successful resolve operation.
Assertions for ValueResult.
Command to list version and other build related infos.
Marker interface used in auto-config.
 
Base interface for all views.
Commands which can be performed by the application or bound to keys in a View.
Handles view execution in a non-fullscreen setup.
Spesialisation of a ViewEvent indicating that a View is done.
 
Base interface for view events.
Base interface for view event args.
Provides services for a View like handling modals.
WindowView is a View defining area within view itself.
Completion script generator for a zsh.