term

Documentation

Overview

Package term provides structures and helper functions to work with terminal (state, sizes).

Index

• Variables
• func HandleCrash(additionalHandlers ...func(interface{}))
• func NewMaxWidthWriter(w io.Writer, maxWidth uint) io.Writer
• func NewPunchCardWriter(w io.Writer) io.Writer
• func NewResponsiveWriter(w io.Writer) io.Writer
• func NewWordWrapWriter(w io.Writer, limit uint) io.Writer
• type SafeFunc
• type TTY
  • func (t TTY) GetSize() *TerminalSize
  • func (t TTY) Safe(fn SafeFunc) error
• type TerminalSize
  • func GetSize(fd uintptr) *TerminalSize
• type TerminalSizeQueue

Variables

var PanicHandlers = []func(context.Context, interface{}){logPanic}

PanicHandlers is a list of functions which will be invoked when a panic happens.

var (
	// ReallyCrash controls the behavior of HandleCrash and defaults to
	// true. It's exposed so components can optionally set to false
	// to restore prior behavior. This flag is mostly used for tests to validate
	// crash conditions.
	ReallyCrash = true
)

Functions

func HandleCrash

func HandleCrash(additionalHandlers ...func(interface{}))

HandleCrash simply catches a crash and logs an error. Meant to be called via defer. Additional context-specific handlers can be provided, and will be called in case of panic. HandleCrash actually crashes, after calling the handlers and logging the panic message.

E.g., you can provide one or more additional handlers for something like shutting down go routines gracefully.

TODO(pohly): logcheck:context // HandleCrashWithContext should be used instead of HandleCrash in code which supports contextual logging.

func NewMaxWidthWriter

func NewMaxWidthWriter(w io.Writer, maxWidth uint) io.Writer

NewMaxWidthWriter is a Writer that supports a limit of characters on every line, but doesn't do any word wrapping automatically.

func NewPunchCardWriter

func NewPunchCardWriter(w io.Writer) io.Writer

NewPunchCardWriter is a NewWordWrapWriter that limits the line width to 80 columns.

func NewResponsiveWriter

func NewResponsiveWriter(w io.Writer) io.Writer

NewResponsiveWriter creates a Writer that detects the column width of the terminal we are in, and adjusts every line width to fit and use recommended terminal sizes for better readability. Does proper word wrapping automatically.

if terminal width >= 120 columns		use 120 columns
if terminal width >= 100 columns		use 100 columns
if terminal width >=  80 columns		use  80 columns

In case we're not in a terminal or if it's smaller than 80 columns width, doesn't do any wrapping.

func NewWordWrapWriter

func NewWordWrapWriter(w io.Writer, limit uint) io.Writer

NewWordWrapWriter is a Writer that supports a limit of characters on every line and does auto word wrapping that respects that limit.

Types

type SafeFunc

type SafeFunc func() error

SafeFunc is a function to be invoked by TTY.

type TTY

type TTY struct {
	// In is a reader representing stdin. It is a required field.
	In io.Reader
	// Out is a writer representing stdout. It must be set to support terminal resizing. It is an
	// optional field.
	Out io.Writer
	// Raw is true if the terminal should be set raw.
	Raw bool
	// TryDev indicates the TTY should try to open /dev/tty if the provided input
	// is not a file descriptor.
	TryDev bool

	// Parent is an optional interrupt handler provided to this function - if provided
	// it will be invoked after the terminal state is restored. If it is not provided,
	// a signal received during the TTY will result in os.Exit(0) being invoked.
	Parent *interrupt.Handler
	// contains filtered or unexported fields
}

TTY helps invoke a function and preserve the state of the terminal, even if the process is terminated during execution. It also provides support for terminal resizing for remote command execution/attachment.

func (TTY) GetSize

func (t TTY) GetSize() *TerminalSize

GetSize returns the current size of the user's terminal. If it isn't a terminal, nil is returned.

func (TTY) Safe

func (t TTY) Safe(fn SafeFunc) error

Safe invokes the provided function and will attempt to ensure that when the function returns (or a termination signal is sent) that the terminal state is reset to the condition it was in prior to the function being invoked. If t.Raw is true the terminal will be put into raw mode prior to calling the function. If the input file descriptor is not a TTY and TryDev is true, the /dev/tty file will be opened (if available).

type TerminalSize

type TerminalSize struct {
	Width  uint16
	Height uint16
}

TerminalSize represents the width and height of a terminal.

func GetSize

func GetSize(fd uintptr) *TerminalSize

GetSize returns the current size of the terminal associated with fd.

type TerminalSizeQueue

type TerminalSizeQueue interface {
	// Next returns the new terminal size after the terminal has been resized. It returns nil when
	// monitoring has been stopped.
	Next() *TerminalSize
}

TerminalSizeQueue is capable of returning terminal resize events as they occur.