Fish has this nice feature of suggesting commands from history without pressing Ctrl+R every time: https://fishshell.com/docs/current/tutorial.html#tut_autosuggestions

Would you like to have something like this implemented in liner?

When terminal size is zero (w = 0), the code will crash.

 thread 'main' panicked at 'attempt to calculate the remainder with a divisor of zero'

Following code will use w for calculation with a divisor of w which is zero.

• https://github.com/MovingtoMars/liner/blob/master/src/editor.rs#L637
• https://github.com/MovingtoMars/liner/blob/master/src/editor.rs#L687

Prior to this patch, typing some text, moving to the start of the line, then deleting until the end of the line and attempting to undo will cause a panic. This is because the truncate() operation did not update the undo list. This has been corrected.

There is currently no way to store a history and load it from a file.

possible sources of inspiration: ion from redox readline written in Go

If this is a desired feature in this project, I will work on it.

I have a cli I am writing that saves some data to file based on an initial run. Re-running loads that file, it would be nice to present the saved values for editing. Other than re-implementing some internal functions of Context, I cannot see a way to do this really. If I could pass my own buffer into an additional read_line method, that would very nicely do it. I'll see if I can come up with a quick PR that demonstrates what I mean.

Using rustc 1.37.0 (eae3437df 2019-08-13), compiling liner v0.4.4 leads to this message:

warning[E0503]: cannot use `self.key_bindings` because it was mutably borrowed
  --> /home/ngirard/.cargo/registry/src/github.com-1ecc6299db9ec823/liner-0.4.4/src/context.rs:98:17
   |
96 |             let ed = try!(Editor::new_with_init_buffer(stdout, prompt, self, buffer));
   |                                                                        ---- borrow of `*self` occurs here
97 |             match self.key_bindings {
98 |                 KeyBindings::Emacs => Self::handle_keys(keymap::Emacs::new(ed), handler),
   |                 ^^^^^^^^^^^^^^^^^^ use of borrowed `*self`
99 |                 KeyBindings::Vi => Self::handle_keys(keymap::Vi::new(ed), handler),
   |                                                                      -- borrow later used here
   |
   = warning: this error has been downgraded to a warning for backwards compatibility with previous releases
   = warning: this represents potential undefined behavior in your code and this warning will become a hard error in the future
   = note: for more information, try `rustc --explain E0729`

I came from the redox-os project which uses liner in ion, and I tried to run set -o vi and found this. Im working on this thing, I forked it and I think I fixed it: :crossed_fingers: . You probably should check my work because I have no idea how this project works.

My fork is here: https://github.com/liamnaddell/liner

Should I pr?

I also "added" two more tests that use ctrl+[ instead of Esc

I've noticed for a while now that liner has a bug where if a command exceeds a certain number of characters, it begins shifting the current line upwards by one line each time a key is entered until it is at the top of the terminal.

This is not good for my use case, where I need to have an editor alongside some static text. (E.g. for editing a field)

Could this be changed to clear::CurrentLine or clear::UntilNewline?

If so, I'll open a PR.

Maybe this is meant this way, but if the history-file has exactly max_file_size lines and another is pushed, the file is cleared completely and the newly pushed is its only entry. The in memory-history works as expected (drops the oldest, but keeps the rest).

How to reproduce (quick and dirty):

$ touch test
$ for x in $(seq 1000); do echo $x >> test; done
$ cat test

This gives 1000 entries.

Compile and run:

extern crate liner;
use liner::Context;

fn main() {
    let mut con = Context::new();
    con.history.set_file_name(Some("test".to_string()));
    con.history.load_history();
    let command = "blabla";
    con.history.push(command.into());
    con.history.commit_history();
}

and then

$ cat test

again. Result only "blabla" will be in the history-file.

So I currently have a limited form of multiline comments / commands in the Ion shell which works great for scripts, but for the REPL there is no means of going back and editing previous lines that have been entered, but not yet submitted for completion. Does liner currently support this feature in some way?

deny processing of inputs by boolean result, basically:

use liner::{Event, Context};
use termion::event::Key;

fn main() {
    let mut line = Context::new();

    line.read_line("$ ", &mut |Event {editor, kind}| -> bool {
        match kind {
            EventKind::BeforeKey(Key::Char(c)) => !c.is_whitespace(),
            _ => true
        }
    });
}

output:

./target/release/liner-test
$ 
# <SPACE> <SPACE> <SPACE> <SPACE>
$ 
# <SPACE> <SPACE> <SPACE> a <SPACE> b <SPACE> c <SPACE>
$ abc

i accomplished this currently, and terribly with Editor::undo.

For example echo foo | ./target/debug/liner_test gives:

thread 'main' panicked at 'called Result::unwrap() on an Err value: Os { code: 25, kind: Other, message: "Inappropriate ioctl for device" }', libcore/result.rs:916:5

The problematic unwrap is at src/context.rs:95, which calls let stdout = stdout().into_raw_mode().unwrap();

This issue also causes redox-os/ion to panic with a redirected stdin. See also: https://github.com/ticki/termion/issues/39

I'm assuming that the main reason that there currently is no windows support for liner is that the termion dependency has no windows support either.

However, there is an open issue here to add that functionality. Once that is merged, It would be great if windows support could be added here as well.

I have a liner fork here that uses a termion fork in order to add this support. I haven't turned it into a PR because I think some more work may be necessary. For example, it seems to work fine on the windows CMD shell, but starting my application using the git Bash shell results in an infinite list of:

[Err] Error { repr: Custom(Custom { kind: Other, error: StringError("Unable to get the terminal size.") }) }

However, it can easily be tested in a project using liner by using my github fork as a dependency:

liner = { git = "https://github.com/jjpe/liner", branch = "windows" }