README

go-prompt

Go Report Card Software License GoDoc tests

A library for building powerful interactive prompts inspired by python-prompt-toolkit, making it easier to build cross-platform command line tools using Go.

package main

import (
	"fmt"
	"github.com/c-bata/go-prompt"
)

func completer(d prompt.Document) []prompt.Suggest {
	s := []prompt.Suggest{
		{Text: "users", Description: "Store the username and age"},
		{Text: "articles", Description: "Store the article text posted by user"},
		{Text: "comments", Description: "Store the text commented to articles"},
	}
	return prompt.FilterHasPrefix(s, d.GetWordBeforeCursor(), true)
}

func main() {
	fmt.Println("Please select table.")
	t := prompt.Input("> ", completer)
	fmt.Println("You selected " + t)
}
Projects using go-prompt

Features

Powerful auto-completion

demo

(This is a GIF animation of kube-prompt.)

Flexible options

go-prompt provides many options. Please check option section of GoDoc for more details.

options

Keyboard Shortcuts

Emacs-like keyboard shortcuts are available by default (these also are the default shortcuts in Bash shell). You can customize and expand these shortcuts.

keyboard shortcuts

Key Binding Description
Ctrl + A Go to the beginning of the line (Home)
Ctrl + E Go to the end of the line (End)
Ctrl + P Previous command (Up arrow)
Ctrl + N Next command (Down arrow)
Ctrl + F Forward one character
Ctrl + B Backward one character
Ctrl + D Delete character under the cursor
Ctrl + H Delete character before the cursor (Backspace)
Ctrl + W Cut the word before the cursor to the clipboard
Ctrl + K Cut the line after the cursor to the clipboard
Ctrl + U Cut the line before the cursor to the clipboard
Ctrl + L Clear the screen
History

You can use Up arrow and Down arrow to walk through the history of commands executed.

History

Multiple platform support

We have confirmed go-prompt works fine in the following terminals:

  • iTerm2 (macOS)
  • Terminal.app (macOS)
  • Command Prompt (Windows)
  • gnome-terminal (Ubuntu)

Author

Masashi Shibata

License

This software is licensed under the MIT license, see LICENSE for more information.

Expand ▾ Collapse ▴

Documentation

Index

Examples

Constants

This section is empty.

Variables

View Source
var ASCIISequences = []*ASCIICode{}/* 112 elements not displayed */

    ASCIISequences holds mappings of the key and byte array.

    View Source
    var (
    	// NewStandardOutputWriter returns ConsoleWriter object to write to stdout.
    	// This generates VT100 escape sequences because almost terminal emulators
    	// in POSIX OS built on top of a VT100 specification.
    	// Deprecated: Please use NewStdoutWriter
    	NewStandardOutputWriter = NewStdoutWriter
    )
    View Source
    var SwitchKeyBindMode = OptionSwitchKeyBindMode

      SwitchKeyBindMode to set a key bind mode. Deprecated: Please use OptionSwitchKeyBindMode.

      Functions

      func Choose

      func Choose(prefix string, choices []string, opts ...Option) string

        Choose to the shortcut of input function to select from string array. Deprecated: Maybe anyone want to use this.

        func DeleteBeforeChar

        func DeleteBeforeChar(buf *Buffer)

          DeleteBeforeChar Go to Backspace

          func DeleteChar

          func DeleteChar(buf *Buffer)

            DeleteChar Delete character under the cursor

            func DeleteWord

            func DeleteWord(buf *Buffer)

              DeleteWord Delete word before the cursor

              func GoLeftChar

              func GoLeftChar(buf *Buffer)

                GoLeftChar Backward one character

                func GoLeftWord

                func GoLeftWord(buf *Buffer)

                  GoLeftWord Backward one word

                  func GoLineBeginning

                  func GoLineBeginning(buf *Buffer)

                    GoLineBeginning Go to the beginning of the line

                    func GoLineEnd

                    func GoLineEnd(buf *Buffer)

                      GoLineEnd Go to the End of the line

                      func GoRightChar

                      func GoRightChar(buf *Buffer)

                        GoRightChar Forward one character

                        func GoRightWord

                        func GoRightWord(buf *Buffer)

                          GoRightWord Forward one word

                          func Input

                          func Input(prefix string, completer Completer, opts ...Option) string

                            Input get the input data from the user and return it.

                            Types

                            type ASCIICode

                            type ASCIICode struct {
                            	Key       Key
                            	ASCIICode []byte
                            }

                              ASCIICode is the type contains Key and it's ascii byte array.

                              type ASCIICodeBind

                              type ASCIICodeBind struct {
                              	ASCIICode []byte
                              	Fn        KeyBindFunc
                              }

                                ASCIICodeBind represents which []byte should do what operation

                                type Buffer

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

                                  Buffer emulates the console buffer.

                                  func NewBuffer

                                  func NewBuffer() (b *Buffer)

                                    NewBuffer is constructor of Buffer struct.

                                    func (*Buffer) CursorDown

                                    func (b *Buffer) CursorDown(count int)

                                      CursorDown move cursor to the next line. (for multi-line edit).

                                      func (*Buffer) CursorLeft

                                      func (b *Buffer) CursorLeft(count int)

                                        CursorLeft move to left on the current line.

                                        func (*Buffer) CursorRight

                                        func (b *Buffer) CursorRight(count int)

                                          CursorRight move to right on the current line.

                                          func (*Buffer) CursorUp

                                          func (b *Buffer) CursorUp(count int)

                                            CursorUp move cursor to the previous line. (for multi-line edit).

                                            func (*Buffer) Delete

                                            func (b *Buffer) Delete(count int) (deleted string)

                                              Delete specified number of characters and Return the deleted text.

                                              func (*Buffer) DeleteBeforeCursor

                                              func (b *Buffer) DeleteBeforeCursor(count int) (deleted string)

                                                DeleteBeforeCursor delete specified number of characters before cursor and return the deleted text.

                                                func (*Buffer) DisplayCursorPosition

                                                func (b *Buffer) DisplayCursorPosition() int

                                                  DisplayCursorPosition returns the cursor position on rendered text on terminal emulators. So if Document is "日本(cursor)語", DisplayedCursorPosition returns 4 because '日' and '本' are double width characters.

                                                  func (*Buffer) Document

                                                  func (b *Buffer) Document() (d *Document)

                                                    Document method to return document instance from the current text and cursor position.

                                                    func (*Buffer) InsertText

                                                    func (b *Buffer) InsertText(v string, overwrite bool, moveCursor bool)

                                                      InsertText insert string from current line.

                                                      func (*Buffer) JoinNextLine

                                                      func (b *Buffer) JoinNextLine(separator string)

                                                        JoinNextLine joins the next line to the current one by deleting the line ending after the current line.

                                                        func (*Buffer) NewLine

                                                        func (b *Buffer) NewLine(copyMargin bool)

                                                          NewLine means CR.

                                                          func (*Buffer) SwapCharactersBeforeCursor

                                                          func (b *Buffer) SwapCharactersBeforeCursor()

                                                            SwapCharactersBeforeCursor swaps the last two characters before the cursor.

                                                            func (*Buffer) Text

                                                            func (b *Buffer) Text() string

                                                              Text returns string of the current line.

                                                              type Color

                                                              type Color int

                                                                Color represents color on terminal.

                                                                const (
                                                                	// DefaultColor represents a default color.
                                                                	DefaultColor Color = iota
                                                                
                                                                	// Black represents a black.
                                                                	Black
                                                                	// DarkRed represents a dark red.
                                                                	DarkRed
                                                                	// DarkGreen represents a dark green.
                                                                	DarkGreen
                                                                	// Brown represents a brown.
                                                                	Brown
                                                                	// DarkBlue represents a dark blue.
                                                                	DarkBlue
                                                                	// Purple represents a purple.
                                                                	Purple
                                                                	// Cyan represents a cyan.
                                                                	Cyan
                                                                	// LightGray represents a light gray.
                                                                	LightGray
                                                                
                                                                	// DarkGray represents a dark gray.
                                                                	DarkGray
                                                                	// Red represents a red.
                                                                	Red
                                                                	// Green represents a green.
                                                                	Green
                                                                	// Yellow represents a yellow.
                                                                	Yellow
                                                                	// Blue represents a blue.
                                                                	Blue
                                                                	// Fuchsia represents a fuchsia.
                                                                	Fuchsia
                                                                	// Turquoise represents a turquoise.
                                                                	Turquoise
                                                                	// White represents a white.
                                                                	White
                                                                )

                                                                type Completer

                                                                type Completer func(Document) []Suggest

                                                                  Completer should return the suggest item from Document.

                                                                  type CompletionManager

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

                                                                    CompletionManager manages which suggestion is now selected.

                                                                    func NewCompletionManager

                                                                    func NewCompletionManager(completer Completer, max uint16) *CompletionManager

                                                                      NewCompletionManager returns initialized CompletionManager object.

                                                                      func (*CompletionManager) Completing

                                                                      func (c *CompletionManager) Completing() bool

                                                                        Completing returns whether the CompletionManager selects something one.

                                                                        func (*CompletionManager) GetSelectedSuggestion

                                                                        func (c *CompletionManager) GetSelectedSuggestion() (s Suggest, ok bool)

                                                                          GetSelectedSuggestion returns the selected item.

                                                                          func (*CompletionManager) GetSuggestions

                                                                          func (c *CompletionManager) GetSuggestions() []Suggest

                                                                            GetSuggestions returns the list of suggestion.

                                                                            func (*CompletionManager) Next

                                                                            func (c *CompletionManager) Next()

                                                                              Next to select the next suggestion item.

                                                                              func (*CompletionManager) Previous

                                                                              func (c *CompletionManager) Previous()

                                                                                Previous to select the previous suggestion item.

                                                                                func (*CompletionManager) Reset

                                                                                func (c *CompletionManager) Reset()

                                                                                  Reset to select nothing.

                                                                                  func (*CompletionManager) Update

                                                                                  func (c *CompletionManager) Update(in Document)

                                                                                    Update to update the suggestions.

                                                                                    type ConsoleParser

                                                                                    type ConsoleParser interface {
                                                                                    	// Setup should be called before starting input
                                                                                    	Setup() error
                                                                                    	// TearDown should be called after stopping input
                                                                                    	TearDown() error
                                                                                    	// GetWinSize returns WinSize object to represent width and height of terminal.
                                                                                    	GetWinSize() *WinSize
                                                                                    	// Read returns byte array.
                                                                                    	Read() ([]byte, error)
                                                                                    }

                                                                                      ConsoleParser is an interface to abstract input layer.

                                                                                      type ConsoleWriter

                                                                                      type ConsoleWriter interface {
                                                                                      
                                                                                      	// WriteRaw to write raw byte array.
                                                                                      	WriteRaw(data []byte)
                                                                                      	// Write to write safety byte array by removing control sequences.
                                                                                      	Write(data []byte)
                                                                                      	// WriteStr to write raw string.
                                                                                      	WriteRawStr(data string)
                                                                                      	// WriteStr to write safety string by removing control sequences.
                                                                                      	WriteStr(data string)
                                                                                      	// Flush to flush buffer.
                                                                                      	Flush() error
                                                                                      
                                                                                      	// EraseScreen erases the screen with the background colour and moves the cursor to home.
                                                                                      	EraseScreen()
                                                                                      	// EraseUp erases the screen from the current line up to the top of the screen.
                                                                                      	EraseUp()
                                                                                      	// EraseDown erases the screen from the current line down to the bottom of the screen.
                                                                                      	EraseDown()
                                                                                      	// EraseStartOfLine erases from the current cursor position to the start of the current line.
                                                                                      	EraseStartOfLine()
                                                                                      	// EraseEndOfLine erases from the current cursor position to the end of the current line.
                                                                                      	EraseEndOfLine()
                                                                                      	// EraseLine erases the entire current line.
                                                                                      	EraseLine()
                                                                                      
                                                                                      	// ShowCursor stops blinking cursor and show.
                                                                                      	ShowCursor()
                                                                                      	// HideCursor hides cursor.
                                                                                      	HideCursor()
                                                                                      	// CursorGoTo sets the cursor position where subsequent text will begin.
                                                                                      	CursorGoTo(row, col int)
                                                                                      	// CursorUp moves the cursor up by 'n' rows; the default count is 1.
                                                                                      	CursorUp(n int)
                                                                                      	// CursorDown moves the cursor down by 'n' rows; the default count is 1.
                                                                                      	CursorDown(n int)
                                                                                      	// CursorForward moves the cursor forward by 'n' columns; the default count is 1.
                                                                                      	CursorForward(n int)
                                                                                      	// CursorBackward moves the cursor backward by 'n' columns; the default count is 1.
                                                                                      	CursorBackward(n int)
                                                                                      	// AskForCPR asks for a cursor position report (CPR).
                                                                                      	AskForCPR()
                                                                                      	// SaveCursor saves current cursor position.
                                                                                      	SaveCursor()
                                                                                      	// UnSaveCursor restores cursor position after a Save Cursor.
                                                                                      	UnSaveCursor()
                                                                                      
                                                                                      	// ScrollDown scrolls display down one line.
                                                                                      	ScrollDown()
                                                                                      	// ScrollUp scroll display up one line.
                                                                                      	ScrollUp()
                                                                                      
                                                                                      	// SetTitle sets a title of terminal window.
                                                                                      	SetTitle(title string)
                                                                                      	// ClearTitle clears a title of terminal window.
                                                                                      	ClearTitle()
                                                                                      
                                                                                      	// SetColor sets text and background colors. and specify whether text is bold.
                                                                                      	SetColor(fg, bg Color, bold bool)
                                                                                      }

                                                                                        ConsoleWriter is an interface to abstract output layer.

                                                                                        func NewStderrWriter

                                                                                        func NewStderrWriter() ConsoleWriter

                                                                                          NewStderrWriter returns ConsoleWriter object to write to stderr. This generates VT100 escape sequences because almost terminal emulators in POSIX OS built on top of a VT100 specification.

                                                                                          func NewStdoutWriter

                                                                                          func NewStdoutWriter() ConsoleWriter

                                                                                            NewStdoutWriter returns ConsoleWriter object to write to stdout. This generates VT100 escape sequences because almost terminal emulators in POSIX OS built on top of a VT100 specification.

                                                                                            type DisplayAttribute

                                                                                            type DisplayAttribute int

                                                                                              DisplayAttribute represents display attributes like Blinking, Bold, Italic and so on.

                                                                                              const (
                                                                                              	// DisplayReset reset all display attributes.
                                                                                              	DisplayReset DisplayAttribute = iota
                                                                                              	// DisplayBold set bold or increases intensity.
                                                                                              	DisplayBold
                                                                                              	// DisplayLowIntensity decreases intensity. Not widely supported.
                                                                                              	DisplayLowIntensity
                                                                                              	// DisplayItalic set italic. Not widely supported.
                                                                                              	DisplayItalic
                                                                                              	// DisplayUnderline set underline
                                                                                              	DisplayUnderline
                                                                                              	// DisplayBlink set blink (less than 150 per minute).
                                                                                              	DisplayBlink
                                                                                              	// DisplayRapidBlink set blink (more than 150 per minute). Not widely supported.
                                                                                              	DisplayRapidBlink
                                                                                              	// DisplayReverse swap foreground and background colors.
                                                                                              	DisplayReverse
                                                                                              	// DisplayInvisible set invisible.  Not widely supported.
                                                                                              	DisplayInvisible
                                                                                              	// DisplayCrossedOut set characters legible, but marked for deletion. Not widely supported.
                                                                                              	DisplayCrossedOut
                                                                                              	// DisplayDefaultFont set primary(default) font
                                                                                              	DisplayDefaultFont
                                                                                              )

                                                                                              type Document

                                                                                              type Document struct {
                                                                                              	Text string
                                                                                              	// contains filtered or unexported fields
                                                                                              }

                                                                                                Document has text displayed in terminal and cursor position.

                                                                                                func NewDocument

                                                                                                func NewDocument() *Document

                                                                                                  NewDocument return the new empty document.

                                                                                                  func (*Document) CurrentLine

                                                                                                  func (d *Document) CurrentLine() string

                                                                                                    CurrentLine return the text on the line where the cursor is. (when the input consists of just one line, it equals `text`.

                                                                                                    Example
                                                                                                    Output:
                                                                                                    
                                                                                                    This is a example of Document component.
                                                                                                    

                                                                                                    func (*Document) CurrentLineAfterCursor

                                                                                                    func (d *Document) CurrentLineAfterCursor() string

                                                                                                      CurrentLineAfterCursor returns the text from the cursor until the end of the line.

                                                                                                      Example
                                                                                                      Output:
                                                                                                      
                                                                                                      ple of Document component.
                                                                                                      

                                                                                                      func (*Document) CurrentLineBeforeCursor

                                                                                                      func (d *Document) CurrentLineBeforeCursor() string

                                                                                                        CurrentLineBeforeCursor returns the text from the start of the line until the cursor.

                                                                                                        Example
                                                                                                        Output:
                                                                                                        
                                                                                                        This is a exam
                                                                                                        

                                                                                                        func (*Document) CursorPositionCol

                                                                                                        func (d *Document) CursorPositionCol() (col int)

                                                                                                          CursorPositionCol returns the current column. (0-based.)

                                                                                                          Example
                                                                                                          Output:
                                                                                                          
                                                                                                          CursorPositionCol 14
                                                                                                          

                                                                                                          func (*Document) CursorPositionRow

                                                                                                          func (d *Document) CursorPositionRow() (row int)

                                                                                                            CursorPositionRow returns the current row. (0-based.)

                                                                                                            Example
                                                                                                            Output:
                                                                                                            
                                                                                                            CursorPositionRow 1
                                                                                                            

                                                                                                            func (*Document) DisplayCursorPosition

                                                                                                            func (d *Document) DisplayCursorPosition() int

                                                                                                              DisplayCursorPosition returns the cursor position on rendered text on terminal emulators. So if Document is "日本(cursor)語", DisplayedCursorPosition returns 4 because '日' and '本' are double width characters.

                                                                                                              Example
                                                                                                              Output:
                                                                                                              
                                                                                                              DisplayCursorPosition 5
                                                                                                              
                                                                                                              Example (WithJapanese)
                                                                                                              Output:
                                                                                                              
                                                                                                              DisplayCursorPosition 6
                                                                                                              

                                                                                                              func (*Document) FindEndOfCurrentWord

                                                                                                              func (d *Document) FindEndOfCurrentWord() int

                                                                                                                FindEndOfCurrentWord returns an index relative to the cursor position. pointing to the end of the current word. Return 0 if nothing was found.

                                                                                                                func (*Document) FindEndOfCurrentWordUntilSeparator

                                                                                                                func (d *Document) FindEndOfCurrentWordUntilSeparator(sep string) int

                                                                                                                  FindEndOfCurrentWordUntilSeparator is almost the same as FindEndOfCurrentWord. But this can specify Separator. Return 0 if nothing was found.

                                                                                                                  func (*Document) FindEndOfCurrentWordUntilSeparatorIgnoreNextToCursor

                                                                                                                  func (d *Document) FindEndOfCurrentWordUntilSeparatorIgnoreNextToCursor(sep string) int

                                                                                                                    FindEndOfCurrentWordUntilSeparatorIgnoreNextToCursor is almost the same as FindEndOfCurrentWordWithSpace. But this can specify Separator. Return 0 if nothing was found.

                                                                                                                    func (*Document) FindEndOfCurrentWordWithSpace

                                                                                                                    func (d *Document) FindEndOfCurrentWordWithSpace() int

                                                                                                                      FindEndOfCurrentWordWithSpace is almost the same as FindEndOfCurrentWord. The only difference is to ignore contiguous spaces.

                                                                                                                      func (*Document) FindStartOfPreviousWord

                                                                                                                      func (d *Document) FindStartOfPreviousWord() int

                                                                                                                        FindStartOfPreviousWord returns an index relative to the cursor position pointing to the start of the previous word. Return 0 if nothing was found.

                                                                                                                        func (*Document) FindStartOfPreviousWordUntilSeparator

                                                                                                                        func (d *Document) FindStartOfPreviousWordUntilSeparator(sep string) int

                                                                                                                          FindStartOfPreviousWordUntilSeparator is almost the same as FindStartOfPreviousWord. But this can specify Separator. Return 0 if nothing was found.

                                                                                                                          func (*Document) FindStartOfPreviousWordUntilSeparatorIgnoreNextToCursor

                                                                                                                          func (d *Document) FindStartOfPreviousWordUntilSeparatorIgnoreNextToCursor(sep string) int

                                                                                                                            FindStartOfPreviousWordUntilSeparatorIgnoreNextToCursor is almost the same as FindStartOfPreviousWordWithSpace. But this can specify Separator. Return 0 if nothing was found.

                                                                                                                            func (*Document) FindStartOfPreviousWordWithSpace

                                                                                                                            func (d *Document) FindStartOfPreviousWordWithSpace() int

                                                                                                                              FindStartOfPreviousWordWithSpace is almost the same as FindStartOfPreviousWord. The only difference is to ignore contiguous spaces.

                                                                                                                              func (*Document) GetCharRelativeToCursor

                                                                                                                              func (d *Document) GetCharRelativeToCursor(offset int) (r rune)

                                                                                                                                GetCharRelativeToCursor return character relative to cursor position, or empty string

                                                                                                                                func (*Document) GetCursorDownPosition

                                                                                                                                func (d *Document) GetCursorDownPosition(count int, preferredColumn int) int

                                                                                                                                  GetCursorDownPosition return the relative cursor position (character index) where we would be if the user pressed the arrow-down button.

                                                                                                                                  func (*Document) GetCursorLeftPosition

                                                                                                                                  func (d *Document) GetCursorLeftPosition(count int) int

                                                                                                                                    GetCursorLeftPosition returns the relative position for cursor left.

                                                                                                                                    func (*Document) GetCursorRightPosition

                                                                                                                                    func (d *Document) GetCursorRightPosition(count int) int

                                                                                                                                      GetCursorRightPosition returns relative position for cursor right.

                                                                                                                                      func (*Document) GetCursorUpPosition

                                                                                                                                      func (d *Document) GetCursorUpPosition(count int, preferredColumn int) int

                                                                                                                                        GetCursorUpPosition return the relative cursor position (character index) where we would be if the user pressed the arrow-up button.

                                                                                                                                        func (*Document) GetEndOfLinePosition

                                                                                                                                        func (d *Document) GetEndOfLinePosition() int

                                                                                                                                          GetEndOfLinePosition returns relative position for the end of this line.

                                                                                                                                          func (*Document) GetWordAfterCursor

                                                                                                                                          func (d *Document) GetWordAfterCursor() string

                                                                                                                                            GetWordAfterCursor returns the word after the cursor. If we have whitespace after the cursor this returns an empty string.

                                                                                                                                            Example
                                                                                                                                            Output:
                                                                                                                                            
                                                                                                                                            ple
                                                                                                                                            

                                                                                                                                            func (*Document) GetWordAfterCursorUntilSeparator

                                                                                                                                            func (d *Document) GetWordAfterCursorUntilSeparator(sep string) string

                                                                                                                                              GetWordAfterCursorUntilSeparator returns the text after the cursor until next separator.

                                                                                                                                              Example
                                                                                                                                              Output:
                                                                                                                                              
                                                                                                                                              m c-bata
                                                                                                                                              

                                                                                                                                              func (*Document) GetWordAfterCursorUntilSeparatorIgnoreNextToCursor

                                                                                                                                              func (d *Document) GetWordAfterCursorUntilSeparatorIgnoreNextToCursor(sep string) string

                                                                                                                                                GetWordAfterCursorUntilSeparatorIgnoreNextToCursor returns the word after the cursor. Unlike GetWordAfterCursor, it returns string containing space

                                                                                                                                                Example
                                                                                                                                                Output:
                                                                                                                                                
                                                                                                                                                ,i am c-bata
                                                                                                                                                

                                                                                                                                                func (*Document) GetWordAfterCursorWithSpace

                                                                                                                                                func (d *Document) GetWordAfterCursorWithSpace() string

                                                                                                                                                  GetWordAfterCursorWithSpace returns the word after the cursor. Unlike GetWordAfterCursor, it returns string containing space

                                                                                                                                                  Example
                                                                                                                                                  Output:
                                                                                                                                                  
                                                                                                                                                   example
                                                                                                                                                  

                                                                                                                                                  func (*Document) GetWordBeforeCursor

                                                                                                                                                  func (d *Document) GetWordBeforeCursor() string

                                                                                                                                                    GetWordBeforeCursor returns the word before the cursor. If we have whitespace before the cursor this returns an empty string.

                                                                                                                                                    Example
                                                                                                                                                    Output:
                                                                                                                                                    
                                                                                                                                                    exam
                                                                                                                                                    

                                                                                                                                                    func (*Document) GetWordBeforeCursorUntilSeparator

                                                                                                                                                    func (d *Document) GetWordBeforeCursorUntilSeparator(sep string) string

                                                                                                                                                      GetWordBeforeCursorUntilSeparator returns the text before the cursor until next separator.

                                                                                                                                                      Example
                                                                                                                                                      Output:
                                                                                                                                                      
                                                                                                                                                      i am c
                                                                                                                                                      

                                                                                                                                                      func (*Document) GetWordBeforeCursorUntilSeparatorIgnoreNextToCursor

                                                                                                                                                      func (d *Document) GetWordBeforeCursorUntilSeparatorIgnoreNextToCursor(sep string) string

                                                                                                                                                        GetWordBeforeCursorUntilSeparatorIgnoreNextToCursor returns the word before the cursor. Unlike GetWordBeforeCursor, it returns string containing space

                                                                                                                                                        Example
                                                                                                                                                        Output:
                                                                                                                                                        
                                                                                                                                                        i am c-bata,
                                                                                                                                                        

                                                                                                                                                        func (*Document) GetWordBeforeCursorWithSpace

                                                                                                                                                        func (d *Document) GetWordBeforeCursorWithSpace() string

                                                                                                                                                          GetWordBeforeCursorWithSpace returns the word before the cursor. Unlike GetWordBeforeCursor, it returns string containing space

                                                                                                                                                          Example
                                                                                                                                                          Output:
                                                                                                                                                          
                                                                                                                                                          example
                                                                                                                                                          

                                                                                                                                                          func (*Document) LastKeyStroke

                                                                                                                                                          func (d *Document) LastKeyStroke() Key

                                                                                                                                                            LastKeyStroke return the last key pressed in this document.

                                                                                                                                                            func (*Document) LineCount

                                                                                                                                                            func (d *Document) LineCount() int

                                                                                                                                                              LineCount return the number of lines in this document. If the document ends with a trailing \n, that counts as the beginning of a new line.

                                                                                                                                                              func (*Document) Lines

                                                                                                                                                              func (d *Document) Lines() []string

                                                                                                                                                                Lines returns the array of all the lines.

                                                                                                                                                                func (*Document) OnLastLine

                                                                                                                                                                func (d *Document) OnLastLine() bool

                                                                                                                                                                  OnLastLine returns true when we are at the last line.

                                                                                                                                                                  func (*Document) TextAfterCursor

                                                                                                                                                                  func (d *Document) TextAfterCursor() string

                                                                                                                                                                    TextAfterCursor returns the text after the cursor.

                                                                                                                                                                    Example
                                                                                                                                                                    Output:
                                                                                                                                                                    
                                                                                                                                                                    ple of Document component.
                                                                                                                                                                    This component has texts displayed in terminal and cursor position.
                                                                                                                                                                    

                                                                                                                                                                    func (*Document) TextBeforeCursor

                                                                                                                                                                    func (d *Document) TextBeforeCursor() string

                                                                                                                                                                      TextBeforeCursor returns the text before the cursor.

                                                                                                                                                                      Example
                                                                                                                                                                      Output:
                                                                                                                                                                      
                                                                                                                                                                      Hello! my name is c-bata.
                                                                                                                                                                      This is a exam
                                                                                                                                                                      

                                                                                                                                                                      func (*Document) TranslateIndexToPosition

                                                                                                                                                                      func (d *Document) TranslateIndexToPosition(index int) (row int, col int)

                                                                                                                                                                        TranslateIndexToPosition given an index for the text, return the corresponding (row, col) tuple. (0-based. Returns (0, 0) for index=0.)

                                                                                                                                                                        func (*Document) TranslateRowColToIndex

                                                                                                                                                                        func (d *Document) TranslateRowColToIndex(row int, column int) (index int)

                                                                                                                                                                          TranslateRowColToIndex given a (row, col), return the corresponding index. (Row and col params are 0-based.)

                                                                                                                                                                          type Exec

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

                                                                                                                                                                            Exec is the struct contains user input context.

                                                                                                                                                                            type Executor

                                                                                                                                                                            type Executor func(string)

                                                                                                                                                                              Executor is called when user input something text.

                                                                                                                                                                              type ExitChecker

                                                                                                                                                                              type ExitChecker func(in string, breakline bool) bool

                                                                                                                                                                                ExitChecker is called after user input to check if prompt must stop and exit go-prompt Run loop. User input means: selecting/typing an entry, then, if said entry content matches the ExitChecker function criteria: - immediate exit (if breakline is false) without executor called - exit after typing <return> (meaning breakline is true), and the executor is called first, before exit. Exit means exit go-prompt (not the overall Go program)

                                                                                                                                                                                type Filter

                                                                                                                                                                                type Filter func([]Suggest, string, bool) []Suggest

                                                                                                                                                                                  Filter is the type to filter the prompt.Suggestion array.

                                                                                                                                                                                  type History

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

                                                                                                                                                                                    History stores the texts that are entered.

                                                                                                                                                                                    func NewHistory

                                                                                                                                                                                    func NewHistory() *History

                                                                                                                                                                                      NewHistory returns new history object.

                                                                                                                                                                                      func (*History) Add

                                                                                                                                                                                      func (h *History) Add(input string)

                                                                                                                                                                                        Add to add text in history.

                                                                                                                                                                                        func (*History) Clear

                                                                                                                                                                                        func (h *History) Clear()

                                                                                                                                                                                          Clear to clear the history.

                                                                                                                                                                                          func (*History) Newer

                                                                                                                                                                                          func (h *History) Newer(buf *Buffer) (new *Buffer, changed bool)

                                                                                                                                                                                            Newer saves a buffer of current line and get a buffer of next line by up-arrow. The changes of line buffers are stored until new history is created.

                                                                                                                                                                                            func (*History) Older

                                                                                                                                                                                            func (h *History) Older(buf *Buffer) (new *Buffer, changed bool)

                                                                                                                                                                                              Older saves a buffer of current line and get a buffer of previous line by up-arrow. The changes of line buffers are stored until new history is created.

                                                                                                                                                                                              type Key

                                                                                                                                                                                              type Key int

                                                                                                                                                                                                Key is the type express the key inserted from user.

                                                                                                                                                                                                const (
                                                                                                                                                                                                	Escape Key = iota
                                                                                                                                                                                                
                                                                                                                                                                                                	ControlA
                                                                                                                                                                                                	ControlB
                                                                                                                                                                                                	ControlC
                                                                                                                                                                                                	ControlD
                                                                                                                                                                                                	ControlE
                                                                                                                                                                                                	ControlF
                                                                                                                                                                                                	ControlG
                                                                                                                                                                                                	ControlH
                                                                                                                                                                                                	ControlI
                                                                                                                                                                                                	ControlJ
                                                                                                                                                                                                	ControlK
                                                                                                                                                                                                	ControlL
                                                                                                                                                                                                	ControlM
                                                                                                                                                                                                	ControlN
                                                                                                                                                                                                	ControlO
                                                                                                                                                                                                	ControlP
                                                                                                                                                                                                	ControlQ
                                                                                                                                                                                                	ControlR
                                                                                                                                                                                                	ControlS
                                                                                                                                                                                                	ControlT
                                                                                                                                                                                                	ControlU
                                                                                                                                                                                                	ControlV
                                                                                                                                                                                                	ControlW
                                                                                                                                                                                                	ControlX
                                                                                                                                                                                                	ControlY
                                                                                                                                                                                                	ControlZ
                                                                                                                                                                                                
                                                                                                                                                                                                	ControlSpace
                                                                                                                                                                                                	ControlBackslash
                                                                                                                                                                                                	ControlSquareClose
                                                                                                                                                                                                	ControlCircumflex
                                                                                                                                                                                                	ControlUnderscore
                                                                                                                                                                                                	ControlLeft
                                                                                                                                                                                                	ControlRight
                                                                                                                                                                                                	ControlUp
                                                                                                                                                                                                	ControlDown
                                                                                                                                                                                                
                                                                                                                                                                                                	Up
                                                                                                                                                                                                	Down
                                                                                                                                                                                                	Right
                                                                                                                                                                                                	Left
                                                                                                                                                                                                
                                                                                                                                                                                                	ShiftLeft
                                                                                                                                                                                                	ShiftUp
                                                                                                                                                                                                	ShiftDown
                                                                                                                                                                                                	ShiftRight
                                                                                                                                                                                                
                                                                                                                                                                                                	Home
                                                                                                                                                                                                	End
                                                                                                                                                                                                	Delete
                                                                                                                                                                                                	ShiftDelete
                                                                                                                                                                                                	ControlDelete
                                                                                                                                                                                                	PageUp
                                                                                                                                                                                                	PageDown
                                                                                                                                                                                                	BackTab
                                                                                                                                                                                                	Insert
                                                                                                                                                                                                	Backspace
                                                                                                                                                                                                
                                                                                                                                                                                                	// Aliases.
                                                                                                                                                                                                	Tab
                                                                                                                                                                                                	Enter
                                                                                                                                                                                                
                                                                                                                                                                                                	F1
                                                                                                                                                                                                	F2
                                                                                                                                                                                                	F3
                                                                                                                                                                                                	F4
                                                                                                                                                                                                	F5
                                                                                                                                                                                                	F6
                                                                                                                                                                                                	F7
                                                                                                                                                                                                	F8
                                                                                                                                                                                                	F9
                                                                                                                                                                                                	F10
                                                                                                                                                                                                	F11
                                                                                                                                                                                                	F12
                                                                                                                                                                                                	F13
                                                                                                                                                                                                	F14
                                                                                                                                                                                                	F15
                                                                                                                                                                                                	F16
                                                                                                                                                                                                	F17
                                                                                                                                                                                                	F18
                                                                                                                                                                                                	F19
                                                                                                                                                                                                	F20
                                                                                                                                                                                                	F21
                                                                                                                                                                                                	F22
                                                                                                                                                                                                	F23
                                                                                                                                                                                                	F24
                                                                                                                                                                                                
                                                                                                                                                                                                	// Matches any key.
                                                                                                                                                                                                	Any
                                                                                                                                                                                                
                                                                                                                                                                                                	// Special
                                                                                                                                                                                                	CPRResponse
                                                                                                                                                                                                	Vt100MouseEvent
                                                                                                                                                                                                	WindowsMouseEvent
                                                                                                                                                                                                	BracketedPaste
                                                                                                                                                                                                
                                                                                                                                                                                                	// Key which is ignored. (The key binding for this key should not do anything.)
                                                                                                                                                                                                	Ignore
                                                                                                                                                                                                
                                                                                                                                                                                                	// Key is not defined
                                                                                                                                                                                                	NotDefined
                                                                                                                                                                                                )

                                                                                                                                                                                                func GetKey

                                                                                                                                                                                                func GetKey(b []byte) Key

                                                                                                                                                                                                  GetKey returns Key correspond to input byte codes.

                                                                                                                                                                                                  func (Key) String

                                                                                                                                                                                                  func (i Key) String() string

                                                                                                                                                                                                  type KeyBind

                                                                                                                                                                                                  type KeyBind struct {
                                                                                                                                                                                                  	Key Key
                                                                                                                                                                                                  	Fn  KeyBindFunc
                                                                                                                                                                                                  }

                                                                                                                                                                                                    KeyBind represents which key should do what operation.

                                                                                                                                                                                                    type KeyBindFunc

                                                                                                                                                                                                    type KeyBindFunc func(*Buffer)

                                                                                                                                                                                                      KeyBindFunc receives buffer and processed it.

                                                                                                                                                                                                      type KeyBindMode

                                                                                                                                                                                                      type KeyBindMode string

                                                                                                                                                                                                        KeyBindMode to switch a key binding flexibly.

                                                                                                                                                                                                        const (
                                                                                                                                                                                                        	// CommonKeyBind is a mode without any keyboard shortcut
                                                                                                                                                                                                        	CommonKeyBind KeyBindMode = "common"
                                                                                                                                                                                                        	// EmacsKeyBind is a mode to use emacs-like keyboard shortcut
                                                                                                                                                                                                        	EmacsKeyBind KeyBindMode = "emacs"
                                                                                                                                                                                                        )

                                                                                                                                                                                                        type Option

                                                                                                                                                                                                        type Option func(prompt *Prompt) error

                                                                                                                                                                                                          Option is the type to replace default parameters. prompt.New accepts any number of options (this is functional option pattern).

                                                                                                                                                                                                          func OptionAddASCIICodeBind

                                                                                                                                                                                                          func OptionAddASCIICodeBind(b ...ASCIICodeBind) Option

                                                                                                                                                                                                            OptionAddASCIICodeBind to set a custom key bind.

                                                                                                                                                                                                            func OptionAddKeyBind

                                                                                                                                                                                                            func OptionAddKeyBind(b ...KeyBind) Option

                                                                                                                                                                                                              OptionAddKeyBind to set a custom key bind.

                                                                                                                                                                                                              func OptionBreakLineCallback

                                                                                                                                                                                                              func OptionBreakLineCallback(fn func(*Document)) Option

                                                                                                                                                                                                                OptionBreakLineCallback to run a callback at every break line

                                                                                                                                                                                                                func OptionCompletionOnDown

                                                                                                                                                                                                                func OptionCompletionOnDown() Option

                                                                                                                                                                                                                  OptionCompletionOnDown allows for Down arrow key to trigger completion.

                                                                                                                                                                                                                  func OptionCompletionWordSeparator

                                                                                                                                                                                                                  func OptionCompletionWordSeparator(x string) Option

                                                                                                                                                                                                                    OptionCompletionWordSeparator to set word separators. Enable only ' ' if empty.

                                                                                                                                                                                                                    func OptionDescriptionBGColor

                                                                                                                                                                                                                    func OptionDescriptionBGColor(x Color) Option

                                                                                                                                                                                                                      OptionDescriptionBGColor to change a background color of description text in drop down suggestions.

                                                                                                                                                                                                                      func OptionDescriptionTextColor

                                                                                                                                                                                                                      func OptionDescriptionTextColor(x Color) Option

                                                                                                                                                                                                                        OptionDescriptionTextColor to change a background color of description text in drop down suggestions.

                                                                                                                                                                                                                        func OptionHistory

                                                                                                                                                                                                                        func OptionHistory(x []string) Option

                                                                                                                                                                                                                          OptionHistory to set history expressed by string array.

                                                                                                                                                                                                                          func OptionInitialBufferText

                                                                                                                                                                                                                          func OptionInitialBufferText(x string) Option

                                                                                                                                                                                                                            OptionInitialBufferText to set the initial buffer text

                                                                                                                                                                                                                            func OptionInputBGColor

                                                                                                                                                                                                                            func OptionInputBGColor(x Color) Option

                                                                                                                                                                                                                              OptionInputBGColor to change a color of background which is input by user

                                                                                                                                                                                                                              func OptionInputTextColor

                                                                                                                                                                                                                              func OptionInputTextColor(x Color) Option

                                                                                                                                                                                                                                OptionInputTextColor to change a color of text which is input by user

                                                                                                                                                                                                                                func OptionLivePrefix

                                                                                                                                                                                                                                func OptionLivePrefix(f func() (prefix string, useLivePrefix bool)) Option

                                                                                                                                                                                                                                  OptionLivePrefix to change the prefix dynamically by callback function

                                                                                                                                                                                                                                  func OptionMaxSuggestion

                                                                                                                                                                                                                                  func OptionMaxSuggestion(x uint16) Option

                                                                                                                                                                                                                                    OptionMaxSuggestion specify the max number of displayed suggestions.

                                                                                                                                                                                                                                    func OptionParser

                                                                                                                                                                                                                                    func OptionParser(x ConsoleParser) Option

                                                                                                                                                                                                                                      OptionParser to set a custom ConsoleParser object. An argument should implement ConsoleParser interface.

                                                                                                                                                                                                                                      func OptionPrefix

                                                                                                                                                                                                                                      func OptionPrefix(x string) Option

                                                                                                                                                                                                                                        OptionPrefix to set prefix string.

                                                                                                                                                                                                                                        func OptionPrefixBackgroundColor

                                                                                                                                                                                                                                        func OptionPrefixBackgroundColor(x Color) Option

                                                                                                                                                                                                                                          OptionPrefixBackgroundColor to change a background color of prefix string

                                                                                                                                                                                                                                          func OptionPrefixTextColor

                                                                                                                                                                                                                                          func OptionPrefixTextColor(x Color) Option

                                                                                                                                                                                                                                            OptionPrefixTextColor change a text color of prefix string

                                                                                                                                                                                                                                            func OptionPreviewSuggestionBGColor

                                                                                                                                                                                                                                            func OptionPreviewSuggestionBGColor(x Color) Option

                                                                                                                                                                                                                                              OptionPreviewSuggestionBGColor to change a background color which is completed

                                                                                                                                                                                                                                              func OptionPreviewSuggestionTextColor

                                                                                                                                                                                                                                              func OptionPreviewSuggestionTextColor(x Color) Option

                                                                                                                                                                                                                                                OptionPreviewSuggestionTextColor to change a text color which is completed

                                                                                                                                                                                                                                                func OptionScrollbarBGColor

                                                                                                                                                                                                                                                func OptionScrollbarBGColor(x Color) Option

                                                                                                                                                                                                                                                  OptionScrollbarBGColor to change a background color of scrollbar.

                                                                                                                                                                                                                                                  func OptionScrollbarThumbColor

                                                                                                                                                                                                                                                  func OptionScrollbarThumbColor(x Color) Option

                                                                                                                                                                                                                                                    OptionScrollbarThumbColor to change a thumb color on scrollbar.

                                                                                                                                                                                                                                                    func OptionSelectedDescriptionBGColor

                                                                                                                                                                                                                                                    func OptionSelectedDescriptionBGColor(x Color) Option

                                                                                                                                                                                                                                                      OptionSelectedDescriptionBGColor to change a background color of description which is selected inside suggestions drop down box.

                                                                                                                                                                                                                                                      func OptionSelectedDescriptionTextColor

                                                                                                                                                                                                                                                      func OptionSelectedDescriptionTextColor(x Color) Option

                                                                                                                                                                                                                                                        OptionSelectedDescriptionTextColor to change a text color of description which is selected inside suggestions drop down box.

                                                                                                                                                                                                                                                        func OptionSelectedSuggestionBGColor

                                                                                                                                                                                                                                                        func OptionSelectedSuggestionBGColor(x Color) Option

                                                                                                                                                                                                                                                          OptionSelectedSuggestionBGColor to change a background color for completed text which is selected inside suggestions drop down box.

                                                                                                                                                                                                                                                          func OptionSelectedSuggestionTextColor

                                                                                                                                                                                                                                                          func OptionSelectedSuggestionTextColor(x Color) Option

                                                                                                                                                                                                                                                            OptionSelectedSuggestionTextColor to change a text color for completed text which is selected inside suggestions drop down box.

                                                                                                                                                                                                                                                            func OptionSetExitCheckerOnInput

                                                                                                                                                                                                                                                            func OptionSetExitCheckerOnInput(fn ExitChecker) Option

                                                                                                                                                                                                                                                              OptionSetExitCheckerOnInput set an exit function which checks if go-prompt exits its Run loop

                                                                                                                                                                                                                                                              func OptionShowCompletionAtStart

                                                                                                                                                                                                                                                              func OptionShowCompletionAtStart() Option

                                                                                                                                                                                                                                                                OptionShowCompletionAtStart to set completion window is open at start.

                                                                                                                                                                                                                                                                func OptionSuggestionBGColor

                                                                                                                                                                                                                                                                func OptionSuggestionBGColor(x Color) Option

                                                                                                                                                                                                                                                                  OptionSuggestionBGColor change a background color in drop down suggestions.

                                                                                                                                                                                                                                                                  func OptionSuggestionTextColor

                                                                                                                                                                                                                                                                  func OptionSuggestionTextColor(x Color) Option

                                                                                                                                                                                                                                                                    OptionSuggestionTextColor to change a text color in drop down suggestions.

                                                                                                                                                                                                                                                                    func OptionSwitchKeyBindMode

                                                                                                                                                                                                                                                                    func OptionSwitchKeyBindMode(m KeyBindMode) Option

                                                                                                                                                                                                                                                                      OptionSwitchKeyBindMode set a key bind mode.

                                                                                                                                                                                                                                                                      func OptionTitle

                                                                                                                                                                                                                                                                      func OptionTitle(x string) Option

                                                                                                                                                                                                                                                                        OptionTitle to set title displayed at the header bar of terminal.

                                                                                                                                                                                                                                                                        func OptionWriter

                                                                                                                                                                                                                                                                        func OptionWriter(x ConsoleWriter) Option

                                                                                                                                                                                                                                                                          OptionWriter to set a custom ConsoleWriter object. An argument should implement ConsoleWriter interface.

                                                                                                                                                                                                                                                                          type PosixParser

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

                                                                                                                                                                                                                                                                            PosixParser is a ConsoleParser implementation for POSIX environment.

                                                                                                                                                                                                                                                                            func NewStandardInputParser

                                                                                                                                                                                                                                                                            func NewStandardInputParser() *PosixParser

                                                                                                                                                                                                                                                                              NewStandardInputParser returns ConsoleParser object to read from stdin.

                                                                                                                                                                                                                                                                              func (*PosixParser) GetWinSize

                                                                                                                                                                                                                                                                              func (t *PosixParser) GetWinSize() *WinSize

                                                                                                                                                                                                                                                                                GetWinSize returns WinSize object to represent width and height of terminal.

                                                                                                                                                                                                                                                                                func (*PosixParser) Read

                                                                                                                                                                                                                                                                                func (t *PosixParser) Read() ([]byte, error)

                                                                                                                                                                                                                                                                                  Read returns byte array.

                                                                                                                                                                                                                                                                                  func (*PosixParser) Setup

                                                                                                                                                                                                                                                                                  func (t *PosixParser) Setup() error

                                                                                                                                                                                                                                                                                    Setup should be called before starting input

                                                                                                                                                                                                                                                                                    func (*PosixParser) TearDown

                                                                                                                                                                                                                                                                                    func (t *PosixParser) TearDown() error

                                                                                                                                                                                                                                                                                      TearDown should be called after stopping input

                                                                                                                                                                                                                                                                                      type PosixWriter

                                                                                                                                                                                                                                                                                      type PosixWriter struct {
                                                                                                                                                                                                                                                                                      	VT100Writer
                                                                                                                                                                                                                                                                                      	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                        PosixWriter is a ConsoleWriter implementation for POSIX environment. To control terminal emulator, this outputs VT100 escape sequences.

                                                                                                                                                                                                                                                                                        func (*PosixWriter) Flush

                                                                                                                                                                                                                                                                                        func (w *PosixWriter) Flush() error

                                                                                                                                                                                                                                                                                          Flush to flush buffer

                                                                                                                                                                                                                                                                                          type Prompt

                                                                                                                                                                                                                                                                                          type Prompt struct {
                                                                                                                                                                                                                                                                                          	ASCIICodeBindings []ASCIICodeBind
                                                                                                                                                                                                                                                                                          	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                            Prompt is core struct of go-prompt.

                                                                                                                                                                                                                                                                                            func New

                                                                                                                                                                                                                                                                                            func New(executor Executor, completer Completer, opts ...Option) *Prompt

                                                                                                                                                                                                                                                                                              New returns a Prompt with powerful auto-completion.

                                                                                                                                                                                                                                                                                              func (*Prompt) Input

                                                                                                                                                                                                                                                                                              func (p *Prompt) Input() string

                                                                                                                                                                                                                                                                                                Input just returns user input text.

                                                                                                                                                                                                                                                                                                func (*Prompt) Run

                                                                                                                                                                                                                                                                                                func (p *Prompt) Run()

                                                                                                                                                                                                                                                                                                  Run starts prompt.

                                                                                                                                                                                                                                                                                                  type Render

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

                                                                                                                                                                                                                                                                                                    Render to render prompt information from state of Buffer.

                                                                                                                                                                                                                                                                                                    func (*Render) BreakLine

                                                                                                                                                                                                                                                                                                    func (r *Render) BreakLine(buffer *Buffer)

                                                                                                                                                                                                                                                                                                      BreakLine to break line.

                                                                                                                                                                                                                                                                                                      func (*Render) Render

                                                                                                                                                                                                                                                                                                      func (r *Render) Render(buffer *Buffer, completion *CompletionManager)

                                                                                                                                                                                                                                                                                                        Render renders to the console.

                                                                                                                                                                                                                                                                                                        func (*Render) Setup

                                                                                                                                                                                                                                                                                                        func (r *Render) Setup()

                                                                                                                                                                                                                                                                                                          Setup to initialize console output.

                                                                                                                                                                                                                                                                                                          func (*Render) TearDown

                                                                                                                                                                                                                                                                                                          func (r *Render) TearDown()

                                                                                                                                                                                                                                                                                                            TearDown to clear title and erasing.

                                                                                                                                                                                                                                                                                                            func (*Render) UpdateWinSize

                                                                                                                                                                                                                                                                                                            func (r *Render) UpdateWinSize(ws *WinSize)

                                                                                                                                                                                                                                                                                                              UpdateWinSize called when window size is changed.

                                                                                                                                                                                                                                                                                                              type Suggest

                                                                                                                                                                                                                                                                                                              type Suggest struct {
                                                                                                                                                                                                                                                                                                              	Text        string
                                                                                                                                                                                                                                                                                                              	Description string
                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                Suggest is printed when completing.

                                                                                                                                                                                                                                                                                                                func FilterContains

                                                                                                                                                                                                                                                                                                                func FilterContains(completions []Suggest, sub string, ignoreCase bool) []Suggest

                                                                                                                                                                                                                                                                                                                  FilterContains checks whether the completion.Text contains sub.

                                                                                                                                                                                                                                                                                                                  func FilterFuzzy

                                                                                                                                                                                                                                                                                                                  func FilterFuzzy(completions []Suggest, sub string, ignoreCase bool) []Suggest

                                                                                                                                                                                                                                                                                                                    FilterFuzzy checks whether the completion.Text fuzzy matches sub. Fuzzy searching for "dog" is equivalent to "*d*o*g*". This search term would match, for example, "Good food is gone"

                                                                                                                                                                                                                                                                                                                    ^  ^      ^
                                                                                                                                                                                                                                                                                                                    

                                                                                                                                                                                                                                                                                                                    func FilterHasPrefix

                                                                                                                                                                                                                                                                                                                    func FilterHasPrefix(completions []Suggest, sub string, ignoreCase bool) []Suggest

                                                                                                                                                                                                                                                                                                                      FilterHasPrefix checks whether the string completions.Text begins with sub.

                                                                                                                                                                                                                                                                                                                      func FilterHasSuffix

                                                                                                                                                                                                                                                                                                                      func FilterHasSuffix(completions []Suggest, sub string, ignoreCase bool) []Suggest

                                                                                                                                                                                                                                                                                                                        FilterHasSuffix checks whether the completion.Text ends with sub.

                                                                                                                                                                                                                                                                                                                        type VT100Writer

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

                                                                                                                                                                                                                                                                                                                          VT100Writer generates VT100 escape sequences.

                                                                                                                                                                                                                                                                                                                          func (*VT100Writer) AskForCPR

                                                                                                                                                                                                                                                                                                                          func (w *VT100Writer) AskForCPR()

                                                                                                                                                                                                                                                                                                                            AskForCPR asks for a cursor position report (CPR).

                                                                                                                                                                                                                                                                                                                            func (*VT100Writer) ClearTitle

                                                                                                                                                                                                                                                                                                                            func (w *VT100Writer) ClearTitle()

                                                                                                                                                                                                                                                                                                                              ClearTitle clears a title of terminal window.

                                                                                                                                                                                                                                                                                                                              func (*VT100Writer) CursorBackward

                                                                                                                                                                                                                                                                                                                              func (w *VT100Writer) CursorBackward(n int)

                                                                                                                                                                                                                                                                                                                                CursorBackward moves the cursor backward by 'n' columns; the default count is 1.

                                                                                                                                                                                                                                                                                                                                func (*VT100Writer) CursorDown

                                                                                                                                                                                                                                                                                                                                func (w *VT100Writer) CursorDown(n int)

                                                                                                                                                                                                                                                                                                                                  CursorDown moves the cursor down by 'n' rows; the default count is 1.

                                                                                                                                                                                                                                                                                                                                  func (*VT100Writer) CursorForward

                                                                                                                                                                                                                                                                                                                                  func (w *VT100Writer) CursorForward(n int)

                                                                                                                                                                                                                                                                                                                                    CursorForward moves the cursor forward by 'n' columns; the default count is 1.

                                                                                                                                                                                                                                                                                                                                    func (*VT100Writer) CursorGoTo

                                                                                                                                                                                                                                                                                                                                    func (w *VT100Writer) CursorGoTo(row, col int)

                                                                                                                                                                                                                                                                                                                                      CursorGoTo sets the cursor position where subsequent text will begin.

                                                                                                                                                                                                                                                                                                                                      func (*VT100Writer) CursorUp

                                                                                                                                                                                                                                                                                                                                      func (w *VT100Writer) CursorUp(n int)

                                                                                                                                                                                                                                                                                                                                        CursorUp moves the cursor up by 'n' rows; the default count is 1.

                                                                                                                                                                                                                                                                                                                                        func (*VT100Writer) EraseDown

                                                                                                                                                                                                                                                                                                                                        func (w *VT100Writer) EraseDown()

                                                                                                                                                                                                                                                                                                                                          EraseDown erases the screen from the current line down to the bottom of the screen.

                                                                                                                                                                                                                                                                                                                                          func (*VT100Writer) EraseEndOfLine

                                                                                                                                                                                                                                                                                                                                          func (w *VT100Writer) EraseEndOfLine()

                                                                                                                                                                                                                                                                                                                                            EraseEndOfLine erases from the current cursor position to the end of the current line.

                                                                                                                                                                                                                                                                                                                                            func (*VT100Writer) EraseLine

                                                                                                                                                                                                                                                                                                                                            func (w *VT100Writer) EraseLine()

                                                                                                                                                                                                                                                                                                                                              EraseLine erases the entire current line.

                                                                                                                                                                                                                                                                                                                                              func (*VT100Writer) EraseScreen

                                                                                                                                                                                                                                                                                                                                              func (w *VT100Writer) EraseScreen()

                                                                                                                                                                                                                                                                                                                                                EraseScreen erases the screen with the background colour and moves the cursor to home.

                                                                                                                                                                                                                                                                                                                                                func (*VT100Writer) EraseStartOfLine

                                                                                                                                                                                                                                                                                                                                                func (w *VT100Writer) EraseStartOfLine()

                                                                                                                                                                                                                                                                                                                                                  EraseStartOfLine erases from the current cursor position to the start of the current line.

                                                                                                                                                                                                                                                                                                                                                  func (*VT100Writer) EraseUp

                                                                                                                                                                                                                                                                                                                                                  func (w *VT100Writer) EraseUp()

                                                                                                                                                                                                                                                                                                                                                    EraseUp erases the screen from the current line up to the top of the screen.

                                                                                                                                                                                                                                                                                                                                                    func (*VT100Writer) HideCursor

                                                                                                                                                                                                                                                                                                                                                    func (w *VT100Writer) HideCursor()

                                                                                                                                                                                                                                                                                                                                                      HideCursor hides cursor.

                                                                                                                                                                                                                                                                                                                                                      func (*VT100Writer) SaveCursor

                                                                                                                                                                                                                                                                                                                                                      func (w *VT100Writer) SaveCursor()

                                                                                                                                                                                                                                                                                                                                                        SaveCursor saves current cursor position.

                                                                                                                                                                                                                                                                                                                                                        func (*VT100Writer) ScrollDown

                                                                                                                                                                                                                                                                                                                                                        func (w *VT100Writer) ScrollDown()

                                                                                                                                                                                                                                                                                                                                                          ScrollDown scrolls display down one line.

                                                                                                                                                                                                                                                                                                                                                          func (*VT100Writer) ScrollUp

                                                                                                                                                                                                                                                                                                                                                          func (w *VT100Writer) ScrollUp()

                                                                                                                                                                                                                                                                                                                                                            ScrollUp scroll display up one line.

                                                                                                                                                                                                                                                                                                                                                            func (*VT100Writer) SetColor

                                                                                                                                                                                                                                                                                                                                                            func (w *VT100Writer) SetColor(fg, bg Color, bold bool)

                                                                                                                                                                                                                                                                                                                                                              SetColor sets text and background colors. and specify whether text is bold.

                                                                                                                                                                                                                                                                                                                                                              func (*VT100Writer) SetDisplayAttributes

                                                                                                                                                                                                                                                                                                                                                              func (w *VT100Writer) SetDisplayAttributes(fg, bg Color, attrs ...DisplayAttribute)

                                                                                                                                                                                                                                                                                                                                                                SetDisplayAttributes to set VT100 display attributes.

                                                                                                                                                                                                                                                                                                                                                                func (*VT100Writer) SetTitle

                                                                                                                                                                                                                                                                                                                                                                func (w *VT100Writer) SetTitle(title string)

                                                                                                                                                                                                                                                                                                                                                                  SetTitle sets a title of terminal window.

                                                                                                                                                                                                                                                                                                                                                                  func (*VT100Writer) ShowCursor

                                                                                                                                                                                                                                                                                                                                                                  func (w *VT100Writer) ShowCursor()

                                                                                                                                                                                                                                                                                                                                                                    ShowCursor stops blinking cursor and show.

                                                                                                                                                                                                                                                                                                                                                                    func (*VT100Writer) UnSaveCursor

                                                                                                                                                                                                                                                                                                                                                                    func (w *VT100Writer) UnSaveCursor()

                                                                                                                                                                                                                                                                                                                                                                      UnSaveCursor restores cursor position after a Save Cursor.

                                                                                                                                                                                                                                                                                                                                                                      func (*VT100Writer) Write

                                                                                                                                                                                                                                                                                                                                                                      func (w *VT100Writer) Write(data []byte)

                                                                                                                                                                                                                                                                                                                                                                        Write to write safety byte array by removing control sequences.

                                                                                                                                                                                                                                                                                                                                                                        func (*VT100Writer) WriteRaw

                                                                                                                                                                                                                                                                                                                                                                        func (w *VT100Writer) WriteRaw(data []byte)

                                                                                                                                                                                                                                                                                                                                                                          WriteRaw to write raw byte array

                                                                                                                                                                                                                                                                                                                                                                          func (*VT100Writer) WriteRawStr

                                                                                                                                                                                                                                                                                                                                                                          func (w *VT100Writer) WriteRawStr(data string)

                                                                                                                                                                                                                                                                                                                                                                            WriteRawStr to write raw string

                                                                                                                                                                                                                                                                                                                                                                            func (*VT100Writer) WriteStr

                                                                                                                                                                                                                                                                                                                                                                            func (w *VT100Writer) WriteStr(data string)

                                                                                                                                                                                                                                                                                                                                                                              WriteStr to write safety string by removing control sequences.

                                                                                                                                                                                                                                                                                                                                                                              type WinSize

                                                                                                                                                                                                                                                                                                                                                                              type WinSize struct {
                                                                                                                                                                                                                                                                                                                                                                              	Row uint16
                                                                                                                                                                                                                                                                                                                                                                              	Col uint16
                                                                                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                                                                                WinSize represents the width and height of terminal.