class Fancyline

Overview

Readline-esque library with some fancy features.

Quick usage

A simple greeter can be built like this:

require "fancyline"

fancy = Fancyline.new
name = fancy.readline("Name: ")
puts "Hello, #{name}"

Have a look in the samples/ directory for more!

Defined in:

fancyline.cr
fancyline/completion.cr
fancyline/context.cr
fancyline/drawable.cr
fancyline/editor.cr
fancyline/history.cr
fancyline/key.cr
fancyline/key_action.cr
fancyline/string_util.cr
fancyline/tty.cr
fancyline/tty/dumb.cr
fancyline/tty/vt100.cr
fancyline/version.cr
fancyline/widget.cr
fancyline/widget/completion.cr
fancyline/widget/history.cr
fancyline/widget/history_search.cr

Constant Summary

VERSION = "0.4.1"

Constructors

Instance Method Summary

Constructor Detail

def self.new(input : IO = STDIN, output : IO = STDOUT, tty : Tty | Nil = nil) #

[View source]

Instance Method Detail

def actions : KeyAction #

Key bindings (or "key map")


[View source]
def autocomplete : Middleware_autocomplete #

Returns the autocomplete middleware object.


[View source]
def call_autocomplete(ctx : Context, range : Range(Int32, Int32), word : String) #

Calls the final stage of autocomplete directly, without calling any previous stages.


[View source]
def call_display(ctx : Context, line : String) #

Calls the final stage of display directly, without calling any previous stages.


[View source]
def call_sub_info(ctx : Context) #

Calls the final stage of sub_info directly, without calling any previous stages.


[View source]
def context : Context | Nil #

Currently active context, if any


[View source]
def display : Middleware_display #

Returns the display middleware object.


[View source]
def grab_output(&) #

Grabs the output: If there's a running prompt, clears it from the screen. Then yields with no arguments. Upon returning, redraws the prompt. If there's no running prompt yields.

Use this method to write data onto the screen while the user is editing the prompt. Such data could be log output while letting the user give commands to a running process.

The redrawing of the prompt happens in an ensure block. Thus, if the block raises, the prompt will be redrawn anyway.

See sample/concurrent_output.cr for sample code.

Note: Raw mode, if currently active on the output, is temporarily disabled during execution of the block.


[View source]
def history : History #

History of previous input


[View source]
def input : IO #

Device to read input from


[View source]
def output : IO #

Device to write terminal output to


[View source]
def raw_from_tc_mode!(fd, mode) #

Copied from IO::FileDescriptor, as this method is sadly private.


[View source]
def readline(prompt, rprompt : String | Nil = nil, history = true) : String | Nil #

Reads a line, showing the prompt. If history is true, the input is added to the #history. Returns the input string, or nil, if the input stream went EOF, this may happen when the user inputs Ctrl-D. The returned string does not end with a new-line, but surrounding whitespace as input by the user is retained.

If rprompt is given, it'll be displayed on the right-hand end of the terminal. If the users input comes near it (Editor::RPROMPT_MARGIN), it will be hidden. If no rprompt is given, none is shown.

If this instance already has a context running it will raise.

Ctrl-C, or an interrupt

By default a key press of Ctrl-C (^C) will raise an Interrupt. Do not confuse this with SIGINT, which is not raised by this method. Nor is a SIGINT sent by a different process caught or handled.

To change the behaviour of raising Interrupt, change the mapping of it:

fancyline.actions.set(Fancyline::Key::Control::CtrlC) do |ctx|
  ctx.reject! # Reject input, make `Fancyline#readline` return `nil`
end

[View source]
def sub_info : Middleware_sub_info #

Returns the sub_info middleware object.


[View source]
def tty : Tty #

TTY control


[View source]
def tty=(tty : Tty) #

TTY control


[View source]