Vendor dependencies

Let's see how I like this workflow.

vendor/crossterm/examples/README.md

@@ -0,0 +1,40 @@
+![Lines of Code][s7] [![MIT][s2]][l2] [![Join us on Discord][s5]][l5]
+
+# Crossterm Examples
+
+The examples are compatible with the latest release.  
+
+## Structure
+
+```
+├── examples
+│   └── interactive-test
+│   └── event-*
+│   └── stderr
+```
+| File Name                   | Description                    | Topics                                    |
+|:----------------------------|:-------------------------------|:------------------------------------------|
+| `examples/interactive-test` | interactive, walk through, demo | cursor, style, event                      |
+| `event-*`                   | event reading demos            | (async) event reading                     |
+| `stderr`                    | crossterm over stderr demo     | raw mode, alternate screen, custom output |
+| `is_tty`                    | Is this instance a tty ?       | tty                                       |
+
+## Run examples
+
+```bash
+$ cargo run --example [file name]
+```
+
+To run the interactive-demo go into the folder `examples/interactive-demo` and run `cargo run`.
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE.md](LICENSE) file for details.
+
+[s2]: https://img.shields.io/badge/license-MIT-blue.svg
+[l2]: LICENSE
+
+[s5]: https://img.shields.io/discord/560857607196377088.svg?logo=discord
+[l5]: https://discord.gg/K4nyTDB
+
+[s7]: https://travis-ci.org/crossterm-rs/examples.svg?branch=master

vendor/crossterm/examples/event-match-modifiers.rs

@@ -0,0 +1,68 @@
+//! Demonstrates how to match on modifiers like: Control, alt, shift.
+//!
+//! cargo run --example event-match-modifiers
+
+use crossterm::event::{Event, KeyCode, KeyEvent, KeyModifiers};
+
+fn match_event(read_event: Event) {
+    match read_event {
+        // Match one one modifier:
+        Event::Key(KeyEvent {
+            modifiers: KeyModifiers::CONTROL,
+            code,
+            ..
+        }) => {
+            println!("Control + {:?}", code);
+        }
+        Event::Key(KeyEvent {
+            modifiers: KeyModifiers::SHIFT,
+            code,
+            ..
+        }) => {
+            println!("Shift + {:?}", code);
+        }
+        Event::Key(KeyEvent {
+            modifiers: KeyModifiers::ALT,
+            code,
+            ..
+        }) => {
+            println!("Alt + {:?}", code);
+        }
+
+        // Match on multiple modifiers:
+        Event::Key(KeyEvent {
+            code, modifiers, ..
+        }) => {
+            if modifiers == (KeyModifiers::ALT | KeyModifiers::SHIFT) {
+                println!("Alt + Shift {:?}", code);
+            } else {
+                println!("({:?}) with key: {:?}", modifiers, code)
+            }
+        }
+
+        _ => {}
+    }
+}
+
+fn main() {
+    match_event(Event::Key(KeyEvent::new(
+        KeyCode::Char('z'),
+        KeyModifiers::CONTROL,
+    )));
+    match_event(Event::Key(KeyEvent::new(
+        KeyCode::Left,
+        KeyModifiers::SHIFT,
+    )));
+    match_event(Event::Key(KeyEvent::new(
+        KeyCode::Delete,
+        KeyModifiers::ALT,
+    )));
+    match_event(Event::Key(KeyEvent::new(
+        KeyCode::Right,
+        KeyModifiers::ALT | KeyModifiers::SHIFT,
+    )));
+    match_event(Event::Key(KeyEvent::new(
+        KeyCode::Home,
+        KeyModifiers::ALT | KeyModifiers::CONTROL,
+    )));
+}

vendor/crossterm/examples/event-poll-read.rs

@@ -0,0 +1,62 @@
+//! Demonstrates how to match on modifiers like: Control, alt, shift.
+//!
+//! cargo run --example event-poll-read
+
+use std::{io::stdout, time::Duration};
+
+use crossterm::{
+    cursor::position,
+    event::{poll, read, DisableMouseCapture, EnableMouseCapture, Event, KeyCode},
+    execute,
+    terminal::{disable_raw_mode, enable_raw_mode},
+    Result,
+};
+
+const HELP: &str = r#"Blocking poll() & non-blocking read()
+ - Keyboard, mouse and terminal resize events enabled
+ - Prints "." every second if there's no event
+ - Hit "c" to print current cursor position
+ - Use Esc to quit
+"#;
+
+fn print_events() -> Result<()> {
+    loop {
+        // Wait up to 1s for another event
+        if poll(Duration::from_millis(1_000))? {
+            // It's guaranteed that read() won't block if `poll` returns `Ok(true)`
+            let event = read()?;
+
+            println!("Event::{:?}\r", event);
+
+            if event == Event::Key(KeyCode::Char('c').into()) {
+                println!("Cursor position: {:?}\r", position());
+            }
+
+            if event == Event::Key(KeyCode::Esc.into()) {
+                break;
+            }
+        } else {
+            // Timeout expired, no event for 1s
+            println!(".\r");
+        }
+    }
+
+    Ok(())
+}
+
+fn main() -> Result<()> {
+    println!("{}", HELP);
+
+    enable_raw_mode()?;
+
+    let mut stdout = stdout();
+    execute!(stdout, EnableMouseCapture)?;
+
+    if let Err(e) = print_events() {
+        println!("Error: {:?}\r", e);
+    }
+
+    execute!(stdout, DisableMouseCapture)?;
+
+    disable_raw_mode()
+}

vendor/crossterm/examples/event-read-char-line.rs

@@ -0,0 +1,45 @@
+//! Demonstrates how to block read characters or a full line.
+//! Just note that crossterm is not required to do this and can be done with `io::stdin()`.
+//!
+//! cargo run --example event-read-char-line
+
+use crossterm::{
+    event::{self, Event, KeyCode, KeyEvent},
+    Result,
+};
+
+pub fn read_char() -> Result<char> {
+    loop {
+        if let Event::Key(KeyEvent {
+            code: KeyCode::Char(c),
+            ..
+        }) = event::read()?
+        {
+            return Ok(c);
+        }
+    }
+}
+
+pub fn read_line() -> Result<String> {
+    let mut line = String::new();
+    while let Event::Key(KeyEvent { code, .. }) = event::read()? {
+        match code {
+            KeyCode::Enter => {
+                break;
+            }
+            KeyCode::Char(c) => {
+                line.push(c);
+            }
+            _ => {}
+        }
+    }
+
+    Ok(line)
+}
+
+fn main() {
+    println!("read line:");
+    println!("{:?}", read_line());
+    println!("read char:");
+    println!("{:?}", read_char());
+}

vendor/crossterm/examples/event-read.rs

@@ -0,0 +1,97 @@
+//! Demonstrates how to block read events.
+//!
+//! cargo run --example event-read
+
+use std::io::stdout;
+
+use crossterm::event::{
+    poll, KeyboardEnhancementFlags, PopKeyboardEnhancementFlags, PushKeyboardEnhancementFlags,
+};
+use crossterm::{
+    cursor::position,
+    event::{
+        read, DisableBracketedPaste, DisableFocusChange, DisableMouseCapture, EnableBracketedPaste,
+        EnableFocusChange, EnableMouseCapture, Event, KeyCode,
+    },
+    execute,
+    terminal::{disable_raw_mode, enable_raw_mode},
+    Result,
+};
+use std::time::Duration;
+
+const HELP: &str = r#"Blocking read()
+ - Keyboard, mouse, focus and terminal resize events enabled
+ - Hit "c" to print current cursor position
+ - Use Esc to quit
+"#;
+
+fn print_events() -> Result<()> {
+    loop {
+        // Blocking read
+        let event = read()?;
+
+        println!("Event: {:?}\r", event);
+
+        if event == Event::Key(KeyCode::Char('c').into()) {
+            println!("Cursor position: {:?}\r", position());
+        }
+
+        if let Event::Resize(x, y) = event {
+            let (original_size, new_size) = flush_resize_events((x, y));
+            println!("Resize from: {:?}, to: {:?}\r", original_size, new_size);
+        }
+
+        if event == Event::Key(KeyCode::Esc.into()) {
+            break;
+        }
+    }
+
+    Ok(())
+}
+
+// Resize events can occur in batches.
+// With a simple loop they can be flushed.
+// This function will keep the first and last resize event.
+fn flush_resize_events(first_resize: (u16, u16)) -> ((u16, u16), (u16, u16)) {
+    let mut last_resize = first_resize;
+    while let Ok(true) = poll(Duration::from_millis(50)) {
+        if let Ok(Event::Resize(x, y)) = read() {
+            last_resize = (x, y);
+        }
+    }
+
+    return (first_resize, last_resize);
+}
+
+fn main() -> Result<()> {
+    println!("{}", HELP);
+
+    enable_raw_mode()?;
+
+    let mut stdout = stdout();
+    execute!(
+        stdout,
+        EnableBracketedPaste,
+        EnableFocusChange,
+        EnableMouseCapture,
+        PushKeyboardEnhancementFlags(
+            KeyboardEnhancementFlags::DISAMBIGUATE_ESCAPE_CODES
+                | KeyboardEnhancementFlags::REPORT_ALL_KEYS_AS_ESCAPE_CODES
+                | KeyboardEnhancementFlags::REPORT_EVENT_TYPES
+        )
+    )?;
+
+    if let Err(e) = print_events() {
+        println!("Error: {:?}\r", e);
+    }
+
+    execute!(
+        stdout,
+        DisableBracketedPaste,
+        PopKeyboardEnhancementFlags,
+        DisableFocusChange,
+        DisableMouseCapture
+    )?;
+
+    disable_raw_mode()
+}

vendor/crossterm/examples/event-stream-async-std.rs

@@ -0,0 +1,68 @@
+//! Demonstrates how to read events asynchronously with async-std.
+//!
+//! cargo run --features="event-stream" --example event-stream-async-std
+
+use std::{io::stdout, time::Duration};
+
+use futures::{future::FutureExt, select, StreamExt};
+use futures_timer::Delay;
+
+use crossterm::{
+    cursor::position,
+    event::{DisableMouseCapture, EnableMouseCapture, Event, EventStream, KeyCode},
+    execute,
+    terminal::{disable_raw_mode, enable_raw_mode},
+    Result,
+};
+
+const HELP: &str = r#"EventStream based on futures_util::stream::Stream with async-std
+ - Keyboard, mouse and terminal resize events enabled
+ - Prints "." every second if there's no event
+ - Hit "c" to print current cursor position
+ - Use Esc to quit
+"#;
+
+async fn print_events() {
+    let mut reader = EventStream::new();
+
+    loop {
+        let mut delay = Delay::new(Duration::from_millis(1_000)).fuse();
+        let mut event = reader.next().fuse();
+
+        select! {
+            _ = delay => { println!(".\r"); },
+            maybe_event = event => {
+                match maybe_event {
+                    Some(Ok(event)) => {
+                        println!("Event::{:?}\r", event);
+
+                        if event == Event::Key(KeyCode::Char('c').into()) {
+                            println!("Cursor position: {:?}\r", position());
+                        }
+
+                        if event == Event::Key(KeyCode::Esc.into()) {
+                            break;
+                        }
+                    }
+                    Some(Err(e)) => println!("Error: {:?}\r", e),
+                    None => break,
+                }
+            }
+        };
+    }
+}
+
+fn main() -> Result<()> {
+    println!("{}", HELP);
+
+    enable_raw_mode()?;
+
+    let mut stdout = stdout();
+    execute!(stdout, EnableMouseCapture)?;
+
+    async_std::task::block_on(print_events());
+
+    execute!(stdout, DisableMouseCapture)?;
+
+    disable_raw_mode()
+}

vendor/crossterm/examples/event-stream-tokio.rs

@@ -0,0 +1,69 @@
+//! Demonstrates how to read events asynchronously with tokio.
+//!
+//! cargo run --features="event-stream" --example event-stream-tokio
+
+use std::{io::stdout, time::Duration};
+
+use futures::{future::FutureExt, select, StreamExt};
+use futures_timer::Delay;
+
+use crossterm::{
+    cursor::position,
+    event::{DisableMouseCapture, EnableMouseCapture, Event, EventStream, KeyCode},
+    execute,
+    terminal::{disable_raw_mode, enable_raw_mode},
+    Result,
+};
+
+const HELP: &str = r#"EventStream based on futures_util::Stream with tokio
+ - Keyboard, mouse and terminal resize events enabled
+ - Prints "." every second if there's no event
+ - Hit "c" to print current cursor position
+ - Use Esc to quit
+"#;
+
+async fn print_events() {
+    let mut reader = EventStream::new();
+
+    loop {
+        let mut delay = Delay::new(Duration::from_millis(1_000)).fuse();
+        let mut event = reader.next().fuse();
+
+        select! {
+            _ = delay => { println!(".\r"); },
+            maybe_event = event => {
+                match maybe_event {
+                    Some(Ok(event)) => {
+                        println!("Event::{:?}\r", event);
+
+                        if event == Event::Key(KeyCode::Char('c').into()) {
+                            println!("Cursor position: {:?}\r", position());
+                        }
+
+                        if event == Event::Key(KeyCode::Esc.into()) {
+                            break;
+                        }
+                    }
+                    Some(Err(e)) => println!("Error: {:?}\r", e),
+                    None => break,
+                }
+            }
+        };
+    }
+}
+
+#[tokio::main]
+async fn main() -> Result<()> {
+    println!("{}", HELP);
+
+    enable_raw_mode()?;
+
+    let mut stdout = stdout();
+    execute!(stdout, EnableMouseCapture)?;
+
+    print_events().await;
+
+    execute!(stdout, DisableMouseCapture)?;
+
+    disable_raw_mode()
+}

vendor/crossterm/examples/is_tty.rs

@@ -0,0 +1,18 @@
+use crossterm::{
+    execute,
+    terminal::{size, SetSize},
+    tty::IsTty,
+};
+use std::io::{stdin, stdout};
+
+pub fn main() {
+    println!("{:?}", size().unwrap());
+    execute!(stdout(), SetSize(10, 10)).unwrap();
+    println!("{:?}", size().unwrap());
+
+    if stdin().is_tty() {
+        println!("Is TTY");
+    } else {
+        println!("Is not TTY");
+    }
+}

vendor/crossterm/examples/stderr.rs

@@ -0,0 +1,96 @@
+//! This shows how an application can write on stderr
+//! instead of stdout, thus making it possible to
+//! the command API instead of the "old style" direct
+//! unbuffered API.
+//!
+//! This particular example is only suited to Unix
+//! for now.
+//!
+//! cargo run --example stderr
+
+use std::io::{stderr, Write};
+
+use crossterm::{
+    cursor::{Hide, MoveTo, Show},
+    event,
+    event::{Event, KeyCode, KeyEvent},
+    execute, queue,
+    style::Print,
+    terminal::{self, EnterAlternateScreen, LeaveAlternateScreen},
+    Result,
+};
+
+const TEXT: &str = r#"
+This screen is ran on stderr.
+And when you hit enter, it prints on stdout.
+This makes it possible to run an application and choose what will
+be sent to any application calling yours.
+
+For example, assuming you build this example with
+
+    cargo build --bin stderr
+
+and then you run it with
+
+    cd "$(target/debug/stderr)"
+
+what the application prints on stdout is used as argument to cd.
+
+Try it out.
+
+Hit any key to quit this screen:
+
+1 will print `..`
+2 will print `/`
+3 will print `~`
+Any other key will print this text (so that you may copy-paste)
+"#;
+
+fn run_app<W>(write: &mut W) -> Result<char>
+where
+    W: Write,
+{
+    queue!(
+        write,
+        EnterAlternateScreen, // enter alternate screen
+        Hide                  // hide the cursor
+    )?;
+
+    let mut y = 1;
+    for line in TEXT.split('\n') {
+        queue!(write, MoveTo(1, y), Print(line.to_string()))?;
+        y += 1;
+    }
+
+    write.flush()?;
+
+    terminal::enable_raw_mode()?;
+    let user_char = read_char()?; // we wait for the user to hit a key
+    execute!(write, Show, LeaveAlternateScreen)?; // restore the cursor and leave the alternate screen
+
+    terminal::disable_raw_mode()?;
+
+    Ok(user_char)
+}
+
+pub fn read_char() -> Result<char> {
+    loop {
+        if let Event::Key(KeyEvent {
+            code: KeyCode::Char(c),
+            ..
+        }) = event::read()?
+        {
+            return Ok(c);
+        }
+    }
+}
+
+// cargo run --example stderr
+fn main() {
+    match run_app(&mut stderr()).unwrap() {
+        '1' => print!(".."),
+        '2' => print!("/"),
+        '3' => print!("~"),
+        _ => println!("{}", TEXT),
+    }
+}